424 lines
14 KiB
JavaScript
424 lines
14 KiB
JavaScript
// Module ID: 1723
|
|
// Function ID: 1724
|
|
// Name: setElementAnimation
|
|
// Dependencies: [1713, 1706, 1658, 1695, 1679, 1710, 1724, 1740, 1664, 1741, 1742, 1747]
|
|
|
|
// Module 1723 (setElementAnimation)
|
|
import isWorkletFunction from "isWorkletFunction" /* 1679 */;
|
|
import isReducedMotionEnabledInSystem from "isReducedMotionEnabledInSystem" /* 1695 */;
|
|
import TransitionType from "TransitionType" /* 1710 */;
|
|
import BaseAnimationBuilder from "BaseAnimationBuilder" /* 1724 */;
|
|
import weakMap from "weakMap" /* 1740 */;
|
|
|
|
require = arg1;
|
|
let dependencyMap = arg6;
|
|
function setElementAnimation(dummy, dummyAnimationConfig, arg2) {
|
|
const _require = dummy;
|
|
dependencyMap = dummyAnimationConfig;
|
|
let flag = arg2;
|
|
if (arg2 === undefined) {
|
|
flag = false;
|
|
}
|
|
let tmp = arg3;
|
|
if (arg3 === undefined) {
|
|
tmp = null;
|
|
}
|
|
c3 = tmp;
|
|
let animationName;
|
|
let duration;
|
|
let delay;
|
|
let easing;
|
|
let maybeRemoveElement;
|
|
c9 = undefined;
|
|
animationName = dummyAnimationConfig.animationName;
|
|
duration = dummyAnimationConfig.duration;
|
|
delay = dummyAnimationConfig.delay;
|
|
easing = dummyAnimationConfig.easing;
|
|
if (dummyAnimationConfig.animationType === _require(1679).LayoutAnimationType.ENTERING) {
|
|
const _requestAnimationFrame = requestAnimationFrame;
|
|
const animationFrame = requestAnimationFrame(function configureAnimation() {
|
|
dummy.style.animationName = animationName;
|
|
dummy.style.animationDuration = "" + duration + "s";
|
|
dummy.style.animationDelay = "" + delay + "s";
|
|
dummy.style.animationTimingFunction = easing;
|
|
});
|
|
} else {
|
|
dummy.style.animationName = animationName;
|
|
const _HermesInternal = HermesInternal;
|
|
dummy.style.animationDuration = "" + duration + "s";
|
|
const _HermesInternal2 = HermesInternal;
|
|
dummy.style.animationDelay = "" + delay + "s";
|
|
dummy.style.animationTimingFunction = easing;
|
|
}
|
|
maybeRemoveElement = function maybeRemoveElement() {
|
|
|
|
};
|
|
c9 = false;
|
|
function maybeCallCallback(arg0) {
|
|
|
|
}
|
|
dummy.onanimationend = () => {
|
|
if (flag) {
|
|
const boundingClientRect = dummy.getBoundingClientRect();
|
|
let obj = { top: null, left: null, width: null, height: null, scrollOffsets: null };
|
|
({ top: obj[0], left: obj[1], width: obj[2], height: obj[3] } = boundingClientRect);
|
|
obj = { scrollTopOffset: 0, scrollLeftOffset: 0 };
|
|
for (let parentElement = dummy; parentElement; parentElement = parentElement.parentElement) {
|
|
let tmp3 = 0 !== parentElement.scrollTop;
|
|
let tmp4 = parentElement;
|
|
if (tmp3) {
|
|
tmp3 = 0 === obj.scrollTopOffset;
|
|
}
|
|
if (tmp3) {
|
|
obj.scrollTopOffset = parentElement.scrollTop;
|
|
}
|
|
let tmp5 = 0 !== parentElement.scrollLeft && 0 === obj.scrollLeftOffset;
|
|
if (tmp5) {
|
|
obj.scrollLeftOffset = parentElement.scrollLeft;
|
|
}
|
|
}
|
|
obj[4] = obj;
|
|
const snapshots = dummy(dummyAnimationConfig[7]).snapshots;
|
|
const result = snapshots.set(dummy, obj);
|
|
const tmp = dummy;
|
|
}
|
|
if (typeof maybeRemoveElement !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let isDummy = dummy.isDummy;
|
|
if (isDummy) {
|
|
let hasItem;
|
|
if (_null != null) {
|
|
hasItem = obj4.contains(obj3);
|
|
}
|
|
isDummy = hasItem;
|
|
obj4 = _null;
|
|
}
|
|
if (isDummy) {
|
|
obj3.removedAfterAnimation = true;
|
|
_null.removeChild(obj3);
|
|
}
|
|
if (typeof maybeCallCallback !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let callback = !c9;
|
|
if (!c9) {
|
|
callback = dummyAnimationConfig.callback;
|
|
}
|
|
if (callback) {
|
|
dummyAnimationConfig.callback(true);
|
|
c9 = true;
|
|
}
|
|
const removed = obj3.removeEventListener("animationcancel", animationCancelHandler);
|
|
};
|
|
function animationCancelHandler() {
|
|
if (typeof maybeRemoveElement !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let isDummy = dummy.isDummy;
|
|
if (isDummy) {
|
|
let hasItem;
|
|
if (_null != null) {
|
|
hasItem = obj2.contains(obj);
|
|
}
|
|
isDummy = hasItem;
|
|
obj2 = _null;
|
|
}
|
|
if (isDummy) {
|
|
obj.removedAfterAnimation = true;
|
|
_null.removeChild(obj);
|
|
}
|
|
if (typeof maybeCallCallback !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let callback = !c9;
|
|
if (!c9) {
|
|
callback = dummyAnimationConfig.callback;
|
|
}
|
|
if (callback) {
|
|
dummyAnimationConfig.callback(false);
|
|
c9 = true;
|
|
}
|
|
const removed = obj.removeEventListener("animationcancel", animationCancelHandler);
|
|
}
|
|
dummy.onanimationstart = () => {
|
|
if (dummyAnimationConfig.animationType === dummy(dummyAnimationConfig[4]).LayoutAnimationType.ENTERING) {
|
|
dummy(dummyAnimationConfig[8])._updatePropsJS({ visibility: "initial" }, dummy);
|
|
const tmpResult = dummy(dummyAnimationConfig[8]);
|
|
}
|
|
const listener = dummy.addEventListener("animationcancel", animationCancelHandler);
|
|
};
|
|
if (!(animationName in _require(1710).Animations)) {
|
|
let result = tmp2(1741).scheduleAnimationCleanup(animationName, duration + delay, () => {
|
|
if (flag) {
|
|
const snapshots = dummy(dummyAnimationConfig[7]).snapshots;
|
|
dummy(dummyAnimationConfig[7]).setElementPosition(dummy, snapshots.get(dummy));
|
|
const obj = dummy(dummyAnimationConfig[7]);
|
|
}
|
|
if (typeof maybeRemoveElement !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let isDummy = dummy.isDummy;
|
|
if (isDummy) {
|
|
let hasItem;
|
|
if (_null != null) {
|
|
hasItem = obj2.contains(tmp5);
|
|
}
|
|
isDummy = hasItem;
|
|
obj2 = _null;
|
|
}
|
|
if (isDummy) {
|
|
tmp5.removedAfterAnimation = true;
|
|
_null.removeChild(tmp5);
|
|
}
|
|
if (typeof maybeCallCallback !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let callback = !c9;
|
|
if (!c9) {
|
|
callback = dummyAnimationConfig.callback;
|
|
}
|
|
if (callback) {
|
|
dummyAnimationConfig.callback(false);
|
|
c9 = true;
|
|
}
|
|
});
|
|
const tmp2Result = tmp2(1741);
|
|
}
|
|
}
|
|
arg5.getReducedMotionFromConfig = function getReducedMotionFromConfig(entering) {
|
|
if (entering.reduceMotionV) {
|
|
const reduceMotionV = entering.reduceMotionV;
|
|
if (isWorkletFunction.ReduceMotion.Never === reduceMotionV) {
|
|
return false;
|
|
} else if (tmp3(1679).ReduceMotion.Always === reduceMotionV) {
|
|
return true;
|
|
} else {
|
|
return tmp3(1695).ReducedMotionManager.jsValue;
|
|
}
|
|
} else {
|
|
return isReducedMotionEnabledInSystem.ReducedMotionManager.jsValue;
|
|
}
|
|
};
|
|
arg5.getProcessedConfig = function getProcessedConfig(animationWithInitialValues, animationType, entering) {
|
|
const obj = { animationName: animationWithInitialValues, animationType, duration: null, delay: null, easing: null, callback: null, reversed: null };
|
|
let num = 0.3;
|
|
if (animationWithInitialValues in TransitionType.Animations) {
|
|
num = tmp(1710).Animations[animationWithInitialValues].duration;
|
|
}
|
|
if (undefined !== entering.durationV) {
|
|
num = entering.durationV / 1000;
|
|
}
|
|
obj[2] = num;
|
|
const randomizeDelay = entering.randomizeDelay;
|
|
let num3 = 0;
|
|
if (randomizeDelay) {
|
|
const _Math = Math;
|
|
const _Math2 = Math;
|
|
num3 = Math.floor(Math.random() * 1001) / 1000;
|
|
}
|
|
if (!entering.delayV) {
|
|
obj[3] = num3;
|
|
if (entering.easingV) {
|
|
const tmp8 = entering.easingV[tmp(undefined, 1706).EasingNameSymbol];
|
|
let tmpResult = tmp(1713);
|
|
if (tmp9) {
|
|
let easingByName = tmpResult.getEasingByName(tmp8);
|
|
} else {
|
|
let maybeGetBezierEasingResult = tmpResult.maybeGetBezierEasing(entering.easingV);
|
|
if (!maybeGetBezierEasingResult) {
|
|
const logger = tmp(1658).logger;
|
|
logger.warn("Selected easing is not currently supported on web. Using linear easing instead.");
|
|
tmpResult = tmp(1713);
|
|
maybeGetBezierEasingResult = tmpResult.getEasingByName("linear");
|
|
}
|
|
easingByName = maybeGetBezierEasingResult;
|
|
}
|
|
tmp9 = tmp8 in tmp(1713).WebEasings;
|
|
} else {
|
|
easingByName = tmp(1713).getEasingByName("linear");
|
|
const tmpResult1 = tmp(1713);
|
|
}
|
|
obj[4] = easingByName;
|
|
let callbackV = null;
|
|
if (undefined !== entering.callbackV) {
|
|
callbackV = entering.callbackV;
|
|
}
|
|
obj[5] = callbackV;
|
|
obj[6] = entering.reversed;
|
|
return obj;
|
|
} else {
|
|
let num6 = entering.delayV;
|
|
if (randomizeDelay) {
|
|
if (num6 === undefined) {
|
|
num6 = 1000;
|
|
}
|
|
const _Math3 = Math;
|
|
const _Math4 = Math;
|
|
num6 = num6 + 1;
|
|
let result = Math.floor(Math.random() * num6) / 1000;
|
|
} else {
|
|
result = num6 / 1000;
|
|
}
|
|
}
|
|
};
|
|
arg5.maybeModifyStyleForKeyframe = function maybeModifyStyleForKeyframe(style, entering) {
|
|
if (entering instanceof BaseAnimationBuilder.Keyframe) {
|
|
style.style.animationFillMode = "forwards";
|
|
const _Object = Object;
|
|
const values = Object.values(entering.definitions);
|
|
const iter = values[Symbol.iterator]();
|
|
const nextResult = iter.next();
|
|
while (iter !== undefined) {
|
|
if (!("originX" in nextResult)) {
|
|
let tmp9 = nextResult;
|
|
}
|
|
let str4 = "absolute";
|
|
style.style.position = "absolute";
|
|
let tmp10 = iter;
|
|
iter.return();
|
|
}
|
|
}
|
|
};
|
|
arg5.saveSnapshot = function saveSnapshot(_componentDOMRef) {
|
|
const size = _componentDOMRef.getBoundingClientRect();
|
|
let obj = { top: size.top, left: size.left, width: size.width, height: size.height, scrollOffsets: null };
|
|
obj = { scrollTopOffset: 0, scrollLeftOffset: 0 };
|
|
for (let parentElement = _componentDOMRef; parentElement; parentElement = parentElement.parentElement) {
|
|
let tmp = 0 !== parentElement.scrollTop;
|
|
let tmp2 = parentElement;
|
|
if (tmp) {
|
|
tmp = 0 === obj.scrollTopOffset;
|
|
}
|
|
if (tmp) {
|
|
obj.scrollTopOffset = parentElement.scrollTop;
|
|
}
|
|
let tmp3 = 0 !== parentElement.scrollLeft && 0 === obj.scrollLeftOffset;
|
|
if (tmp3) {
|
|
obj.scrollLeftOffset = parentElement.scrollLeft;
|
|
}
|
|
}
|
|
obj[4] = obj;
|
|
const snapshots = weakMap.snapshots;
|
|
const result = snapshots.set(_componentDOMRef, obj);
|
|
};
|
|
arg5.setElementAnimation = setElementAnimation;
|
|
arg5.handleLayoutTransition = function handleLayoutTransition(_componentDOMRef, processedConfig, easingY) {
|
|
const animationName = processedConfig.animationName;
|
|
if ("LinearTransition" === animationName) {
|
|
let ENTRY_EXIT = TransitionType.TransitionType.LINEAR;
|
|
let tmp4 = require;
|
|
} else if ("SequencedTransition" === animationName) {
|
|
ENTRY_EXIT = TransitionType.TransitionType.SEQUENCED;
|
|
tmp4 = require;
|
|
} else if ("FadingTransition" === animationName) {
|
|
ENTRY_EXIT = TransitionType.TransitionType.FADING;
|
|
tmp4 = require;
|
|
} else if ("JumpingTransition" === animationName) {
|
|
ENTRY_EXIT = TransitionType.TransitionType.JUMPING;
|
|
tmp4 = require;
|
|
} else if ("CurvedTransition" === animationName) {
|
|
ENTRY_EXIT = TransitionType.TransitionType.CURVED;
|
|
tmp4 = require;
|
|
} else if ("EntryExitTransition" === animationName) {
|
|
ENTRY_EXIT = TransitionType.TransitionType.ENTRY_EXIT;
|
|
tmp4 = require;
|
|
}
|
|
let tmp4Result = tmp4(1742);
|
|
({ dummyTransitionKeyframeName, transitionKeyframeName: processedConfig.animationName } = tmp4Result.TransitionGenerator(ENTRY_EXIT, easingY));
|
|
if (ENTRY_EXIT === tmp4(1710).TransitionType.CURVED) {
|
|
tmp4Result = tmp4(1747);
|
|
const result = tmp4Result.prepareCurvedTransition(_componentDOMRef, processedConfig, easingY, dummyTransitionKeyframeName);
|
|
setElementAnimation(result.dummy, result.dummyAnimationConfig);
|
|
}
|
|
setElementAnimation(_componentDOMRef, processedConfig);
|
|
};
|
|
arg5.handleExitingAnimation = function handleExitingAnimation(offsetParent, processedConfig) {
|
|
let firstChild;
|
|
let parentElement = offsetParent;
|
|
const _require = offsetParent;
|
|
offsetParent = offsetParent.offsetParent;
|
|
const cloneNodeResult = offsetParent.cloneNode();
|
|
dependencyMap = cloneNodeResult;
|
|
cloneNodeResult.isDummy = true;
|
|
cloneNodeResult.style.animationName = "";
|
|
offsetParent.dummyClone = cloneNodeResult;
|
|
offsetParent.style.animationName = "";
|
|
const map = new Map();
|
|
function saveScrollPosition(scrollTop) {
|
|
const result = map.set(scrollTop, { top: scrollTop.scrollTop, left: scrollTop.scrollLeft });
|
|
const arr = Array.from(scrollTop.children);
|
|
const obj = { top: scrollTop.scrollTop, left: scrollTop.scrollLeft };
|
|
while (tmp3 !== undefined) {
|
|
let tmp5 = saveScrollPosition;
|
|
let tmp6 = saveScrollPosition(tmp4);
|
|
continue;
|
|
}
|
|
}
|
|
saveScrollPosition(offsetParent);
|
|
if (offsetParent.firstChild) {
|
|
do {
|
|
let appendChildResult = cloneNodeResult.appendChild(parentElement.firstChild);
|
|
firstChild = parentElement.firstChild;
|
|
} while (firstChild);
|
|
}
|
|
if (offsetParent != null) {
|
|
offsetParent.appendChild(cloneNodeResult);
|
|
}
|
|
function restoreScrollPosition(cloneNodeResult) {
|
|
let tmp2 = cloneNodeResult;
|
|
if (cloneNodeResult === closure_1) {
|
|
tmp2 = closure_0;
|
|
}
|
|
const value = map.get(tmp2);
|
|
if (value) {
|
|
({ top: cloneNodeResult.scrollTop, left: cloneNodeResult.scrollLeft } = value);
|
|
}
|
|
const arr = Array.from(cloneNodeResult.children);
|
|
while (tmp5 !== undefined) {
|
|
let tmp7 = restoreScrollPosition;
|
|
let tmp8 = restoreScrollPosition(tmp6);
|
|
continue;
|
|
}
|
|
}
|
|
let result = restoreScrollPosition(cloneNodeResult);
|
|
const snapshots = _require(1740).snapshots;
|
|
const rect = snapshots.get(parentElement);
|
|
let num = 0;
|
|
let num2 = 0;
|
|
let num3 = 0;
|
|
let num4 = 0;
|
|
while (parentElement) {
|
|
let tmp8 = 0 !== parentElement.scrollTop;
|
|
let scrollLeft = num;
|
|
let scrollTop = num2;
|
|
let tmp9 = parentElement;
|
|
if (tmp8) {
|
|
tmp8 = 0 === scrollTop;
|
|
}
|
|
if (tmp8) {
|
|
scrollTop = parentElement.scrollTop;
|
|
}
|
|
let tmp10 = 0 !== parentElement.scrollLeft && 0 === scrollLeft;
|
|
if (tmp10) {
|
|
scrollLeft = parentElement.scrollLeft;
|
|
}
|
|
parentElement = parentElement.parentElement;
|
|
num = scrollLeft;
|
|
num2 = scrollTop;
|
|
num3 = scrollLeft;
|
|
num4 = scrollTop;
|
|
}
|
|
const scrollTopOffset = rect.scrollOffsets.scrollTopOffset;
|
|
if (num4 !== scrollTopOffset) {
|
|
rect.top = rect.top + (scrollTopOffset - num4);
|
|
}
|
|
const scrollLeftOffset = rect.scrollOffsets.scrollLeftOffset;
|
|
if (num3 !== scrollLeftOffset) {
|
|
rect.left = rect.left + (scrollLeftOffset - num3);
|
|
}
|
|
const snapshots2 = tmp6(1740).snapshots;
|
|
const result1 = snapshots2.set(cloneNodeResult, rect);
|
|
_require(1740).setElementPosition(cloneNodeResult, rect);
|
|
map(cloneNodeResult, processedConfig, false, offsetParent);
|
|
};
|