306 lines
11 KiB
JavaScript
306 lines
11 KiB
JavaScript
// Module ID: 1651
|
|
// Function ID: 18342
|
|
// Name: getEasingFromConfig
|
|
// Dependencies: []
|
|
|
|
// Module 1651 (getEasingFromConfig)
|
|
function getEasingFromConfig(easingV) {
|
|
if (easingV.easingV) {
|
|
const obj2 = arg1(arg6[0]);
|
|
if (tmp6) {
|
|
return obj2.getEasingByName(tmp5);
|
|
} else {
|
|
let maybeGetBezierEasingResult = obj2.maybeGetBezierEasing(easingV.easingV);
|
|
if (!maybeGetBezierEasingResult) {
|
|
const logger = arg1(arg6[2]).logger;
|
|
logger.warn("Selected easing is not currently supported on web. Using linear easing instead.");
|
|
maybeGetBezierEasingResult = arg1(arg6[0]).getEasingByName("linear");
|
|
const obj3 = arg1(arg6[0]);
|
|
}
|
|
return maybeGetBezierEasingResult;
|
|
}
|
|
const tmp6 = easingV.easingV[closure_0(undefined, closure_1[1]).EasingNameSymbol] in arg1(arg6[0]).WebEasings;
|
|
} else {
|
|
return arg1(arg6[0]).getEasingByName("linear");
|
|
}
|
|
}
|
|
function getRandomDelay(delayV) {
|
|
let num = 1000;
|
|
if (arguments.length > 0) {
|
|
num = 1000;
|
|
if (undefined !== arguments[0]) {
|
|
num = arguments[0];
|
|
}
|
|
}
|
|
return Math.floor(Math.random() * (num + 1)) / 1000;
|
|
}
|
|
function getDelayFromConfig(randomizeDelay) {
|
|
randomizeDelay = randomizeDelay.randomizeDelay;
|
|
let num = 0;
|
|
if (randomizeDelay) {
|
|
num = getRandomDelay();
|
|
}
|
|
if (!randomizeDelay.delayV) {
|
|
return num;
|
|
} else if (randomizeDelay) {
|
|
let result = getRandomDelay(tmp.delayV);
|
|
} else {
|
|
result = tmp.delayV / 1000;
|
|
}
|
|
}
|
|
function getDurationFromConfig(durationV, animationWithInitialValues) {
|
|
let num = 0.3;
|
|
if (animationWithInitialValues in animationWithInitialValues(arg6[5]).Animations) {
|
|
num = animationWithInitialValues(arg6[5]).Animations[animationWithInitialValues].duration;
|
|
}
|
|
if (undefined !== durationV.durationV) {
|
|
num = durationV.durationV / 1000;
|
|
}
|
|
return num;
|
|
}
|
|
function getCallbackFromConfig(callbackV) {
|
|
callbackV = null;
|
|
if (undefined !== callbackV.callbackV) {
|
|
callbackV = callbackV.callbackV;
|
|
}
|
|
return callbackV;
|
|
}
|
|
function getReversedFromConfig(reversed) {
|
|
return reversed.reversed;
|
|
}
|
|
function saveSnapshot(_componentDOMRef) {
|
|
const size = _componentDOMRef.getBoundingClientRect();
|
|
const snapshots = arg1(arg6[7]).snapshots;
|
|
const result = snapshots.set(_componentDOMRef, { top: size.top, left: size.left, width: size.width, height: size.height, scrollOffsets: getElementScrollValue(_componentDOMRef) });
|
|
}
|
|
function setElementAnimation(cloneNodeResult, dummyAnimationConfig, arg2, offsetParent) {
|
|
dummyAnimationConfig = cloneNodeResult;
|
|
const arg6 = dummyAnimationConfig;
|
|
let closure_2 = arguments.length > 2 && undefined !== arguments[2] && arguments[2];
|
|
let tmp = null;
|
|
if (arguments.length > 3) {
|
|
tmp = null;
|
|
if (undefined !== arguments[3]) {
|
|
tmp = arguments[3];
|
|
}
|
|
}
|
|
const getRandomDelay = tmp;
|
|
const animationName = dummyAnimationConfig.animationName;
|
|
const getDelayFromConfig = animationName;
|
|
const duration = dummyAnimationConfig.duration;
|
|
const getDurationFromConfig = duration;
|
|
const delay = dummyAnimationConfig.delay;
|
|
const getReversedFromConfig = dummyAnimationConfig.easing;
|
|
function configureAnimation() {
|
|
arg0.style.animationName = animationName;
|
|
arg0.style.animationDuration = "" + duration + "s";
|
|
arg0.style.animationDelay = "" + delay + "s";
|
|
arg0.style.animationTimingFunction = easing;
|
|
}
|
|
if (dummyAnimationConfig.animationType === dummyAnimationConfig(arg6[4]).LayoutAnimationType.ENTERING) {
|
|
const _requestAnimationFrame = requestAnimationFrame;
|
|
const animationFrame = requestAnimationFrame(configureAnimation);
|
|
} else {
|
|
configureAnimation();
|
|
}
|
|
function maybeRemoveElement(arg0) {
|
|
let isDummy = arg0.isDummy;
|
|
if (isDummy) {
|
|
isDummy = null != tmp;
|
|
}
|
|
if (isDummy) {
|
|
isDummy = tmp.contains(arg0);
|
|
}
|
|
if (isDummy) {
|
|
arg0.removedAfterAnimation = true;
|
|
tmp.removeChild(arg0);
|
|
}
|
|
}
|
|
let closure_9 = false;
|
|
function maybeCallCallback(arg0) {
|
|
let callback = !closure_9;
|
|
if (!closure_9) {
|
|
callback = arg1.callback;
|
|
}
|
|
if (callback) {
|
|
arg1.callback(arg0);
|
|
closure_9 = true;
|
|
}
|
|
}
|
|
cloneNodeResult.onanimationend = () => {
|
|
if (closure_2) {
|
|
maybeRemoveElement(arg0);
|
|
}
|
|
maybeRemoveElement();
|
|
maybeCallCallback(true);
|
|
const removed = arg0.removeEventListener("animationcancel", animationCancelHandler);
|
|
};
|
|
function animationCancelHandler() {
|
|
maybeRemoveElement();
|
|
maybeCallCallback(false);
|
|
const removed = arg0.removeEventListener("animationcancel", animationCancelHandler);
|
|
}
|
|
cloneNodeResult.onanimationstart = () => {
|
|
if (arg1.animationType === arg0(arg1[4]).LayoutAnimationType.ENTERING) {
|
|
let obj = arg0(arg1[8]);
|
|
obj = { visibility: "initial" };
|
|
obj._updatePropsJS(obj, arg0);
|
|
}
|
|
const listener = arg0.addEventListener("animationcancel", animationCancelHandler);
|
|
};
|
|
if (!(animationName in dummyAnimationConfig(arg6[5]).Animations)) {
|
|
const result = dummyAnimationConfig(arg6[9]).scheduleAnimationCleanup(animationName, duration + delay, () => {
|
|
if (closure_2) {
|
|
const snapshots = arg0(arg1[7]).snapshots;
|
|
arg0(arg1[7]).setElementPosition(arg0, snapshots.get(arg0));
|
|
const obj = arg0(arg1[7]);
|
|
}
|
|
maybeRemoveElement();
|
|
maybeCallCallback(false);
|
|
});
|
|
const obj = dummyAnimationConfig(arg6[9]);
|
|
}
|
|
}
|
|
function getElementScrollValue(offsetParent) {
|
|
let parentElement = offsetParent;
|
|
const obj = { "Null": false, "Null": true };
|
|
if (offsetParent) {
|
|
do {
|
|
let tmp = 0 !== parentElement.scrollTop && 0 === obj.scrollTopOffset;
|
|
if (tmp) {
|
|
obj.scrollTopOffset = parentElement.scrollTop;
|
|
}
|
|
let tmp2 = 0 !== parentElement.scrollLeft && 0 === obj.scrollLeftOffset;
|
|
if (tmp2) {
|
|
obj.scrollLeftOffset = parentElement.scrollLeft;
|
|
}
|
|
parentElement = parentElement.parentElement;
|
|
} while (parentElement);
|
|
}
|
|
return obj;
|
|
}
|
|
arg5.getReducedMotionFromConfig = function getReducedMotionFromConfig(entering) {
|
|
if (entering.reduceMotionV) {
|
|
const reduceMotionV = entering.reduceMotionV;
|
|
if (arg1(arg6[4]).ReduceMotion.Never === reduceMotionV) {
|
|
return false;
|
|
} else if (arg1(arg6[4]).ReduceMotion.Always === reduceMotionV) {
|
|
return true;
|
|
} else {
|
|
return arg1(arg6[3]).ReducedMotionManager.jsValue;
|
|
}
|
|
} else {
|
|
return arg1(arg6[3]).ReducedMotionManager.jsValue;
|
|
}
|
|
};
|
|
arg5.getProcessedConfig = function getProcessedConfig(animationWithInitialValues, animationType, entering) {
|
|
return { animationName: animationWithInitialValues, animationType, duration: getDurationFromConfig(entering, animationWithInitialValues), delay: getDelayFromConfig(entering), easing: getEasingFromConfig(entering), callback: getCallbackFromConfig(entering), reversed: getReversedFromConfig(entering) };
|
|
};
|
|
arg5.maybeModifyStyleForKeyframe = function maybeModifyStyleForKeyframe(style, entering) {
|
|
if (entering instanceof entering(arg6[6]).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 tmp8 = nextResult;
|
|
}
|
|
let str4 = "absolute";
|
|
style.style.position = "absolute";
|
|
iter.return();
|
|
}
|
|
}
|
|
};
|
|
arg5.saveSnapshot = saveSnapshot;
|
|
arg5.setElementAnimation = setElementAnimation;
|
|
arg5.handleLayoutTransition = function handleLayoutTransition(_componentDOMRef, animationName, easingY) {
|
|
let dummyTransitionKeyframeName;
|
|
animationName = animationName.animationName;
|
|
if ("LinearTransition" === animationName) {
|
|
let ENTRY_EXIT = animationName(arg6[5]).TransitionType.LINEAR;
|
|
} else if ("SequencedTransition" === animationName) {
|
|
ENTRY_EXIT = animationName(arg6[5]).TransitionType.SEQUENCED;
|
|
} else if ("FadingTransition" === animationName) {
|
|
ENTRY_EXIT = animationName(arg6[5]).TransitionType.FADING;
|
|
} else if ("JumpingTransition" === animationName) {
|
|
ENTRY_EXIT = animationName(arg6[5]).TransitionType.JUMPING;
|
|
} else if ("CurvedTransition" === animationName) {
|
|
ENTRY_EXIT = animationName(arg6[5]).TransitionType.CURVED;
|
|
} else if ("EntryExitTransition" === animationName) {
|
|
ENTRY_EXIT = animationName(arg6[5]).TransitionType.ENTRY_EXIT;
|
|
}
|
|
const obj = animationName(arg6[10]);
|
|
({ dummyTransitionKeyframeName, transitionKeyframeName: animationName.animationName } = animationName(arg6[10]).TransitionGenerator(ENTRY_EXIT, easingY));
|
|
if (ENTRY_EXIT === animationName(arg6[5]).TransitionType.CURVED) {
|
|
const obj2 = animationName(arg6[11]);
|
|
const result = obj2.prepareCurvedTransition(_componentDOMRef, animationName, easingY, dummyTransitionKeyframeName);
|
|
setElementAnimation(result.dummy, result.dummyAnimationConfig);
|
|
}
|
|
setElementAnimation(_componentDOMRef, animationName);
|
|
};
|
|
arg5.handleExitingAnimation = function handleExitingAnimation(offsetParent, dummyAnimationConfig) {
|
|
let firstChild;
|
|
dummyAnimationConfig = offsetParent;
|
|
offsetParent = offsetParent.offsetParent;
|
|
const cloneNodeResult = offsetParent.cloneNode();
|
|
const arg6 = cloneNodeResult;
|
|
cloneNodeResult.isDummy = true;
|
|
cloneNodeResult.style.animationName = "";
|
|
offsetParent.dummyClone = cloneNodeResult;
|
|
offsetParent.style.animationName = "";
|
|
const getEasingFromConfig = new Map();
|
|
function saveScrollPosition(scrollTop) {
|
|
const result = map.set(scrollTop, { top: scrollTop.scrollTop, left: scrollTop.scrollLeft });
|
|
for (const item10015 of arr) {
|
|
let tmp3 = closure_3;
|
|
let tmp4 = closure_3(item10015);
|
|
}
|
|
}
|
|
const getRandomDelay = saveScrollPosition;
|
|
saveScrollPosition(offsetParent);
|
|
if (offsetParent.firstChild) {
|
|
do {
|
|
let appendChildResult = cloneNodeResult.appendChild(offsetParent.firstChild);
|
|
firstChild = offsetParent.firstChild;
|
|
} while (firstChild);
|
|
}
|
|
if (null != offsetParent) {
|
|
offsetParent.appendChild(cloneNodeResult);
|
|
}
|
|
function restoreScrollPosition(cloneNodeResult) {
|
|
let tmp2 = cloneNodeResult;
|
|
if (cloneNodeResult === cloneNodeResult) {
|
|
tmp2 = cloneNodeResult;
|
|
}
|
|
const value = map.get(tmp2);
|
|
if (value) {
|
|
({ top: cloneNodeResult.scrollTop, left: cloneNodeResult.scrollLeft } = value);
|
|
}
|
|
for (const item10016 of arr) {
|
|
let tmp5 = closure_4;
|
|
let tmp6 = closure_4(item10016);
|
|
}
|
|
}
|
|
const getDelayFromConfig = restoreScrollPosition;
|
|
const result = restoreScrollPosition(cloneNodeResult);
|
|
const snapshots = dummyAnimationConfig(arg6[7]).snapshots;
|
|
const rect = snapshots.get(offsetParent);
|
|
const tmp6 = getElementScrollValue(offsetParent);
|
|
const scrollTopOffset = tmp6.scrollTopOffset;
|
|
const scrollTopOffset2 = rect.scrollOffsets.scrollTopOffset;
|
|
if (scrollTopOffset !== scrollTopOffset2) {
|
|
rect.top = rect.top + (scrollTopOffset2 - scrollTopOffset);
|
|
}
|
|
const scrollLeftOffset = tmp6.scrollLeftOffset;
|
|
const scrollLeftOffset2 = rect.scrollOffsets.scrollLeftOffset;
|
|
if (scrollLeftOffset !== scrollLeftOffset2) {
|
|
rect.left = rect.left + (scrollLeftOffset2 - scrollLeftOffset);
|
|
}
|
|
const snapshots2 = dummyAnimationConfig(arg6[7]).snapshots;
|
|
const result1 = snapshots2.set(cloneNodeResult, rect);
|
|
const map = new Map();
|
|
dummyAnimationConfig(arg6[7]).setElementPosition(cloneNodeResult, rect);
|
|
setElementAnimation(cloneNodeResult, dummyAnimationConfig, false, offsetParent);
|
|
};
|