111 lines
5.7 KiB
JavaScript
111 lines
5.7 KiB
JavaScript
import { pregenerateKeyframes } from "@motionone/generators";
|
|
import { isNumber, isString, noopReturn } from "@motionone/utils";
|
|
import { getUnitConverter } from "../animate/utils/get-unit";
|
|
import { calcGeneratorVelocity } from "@motionone/generators";
|
|
import { transformDefinitions } from "../animate/utils/transforms";
|
|
import { getStyleName } from "../animate/utils/get-style-name";
|
|
function canGenerate(value) {
|
|
return isNumber(value) && !isNaN(value);
|
|
}
|
|
function getAsNumber(value) {
|
|
return isString(value) ? parseFloat(value) : value;
|
|
}
|
|
export function createGeneratorEasing(createGenerator) {
|
|
const keyframesCache = new WeakMap();
|
|
return (options = {}) => {
|
|
const generatorCache = new Map();
|
|
const getGenerator = (from = 0, to = 100, velocity = 0, isScale = false) => {
|
|
const key = `${from}-${to}-${velocity}-${isScale}`;
|
|
if (!generatorCache.has(key)) {
|
|
generatorCache.set(key, createGenerator(Object.assign({ from,
|
|
to,
|
|
velocity }, options)));
|
|
}
|
|
return generatorCache.get(key);
|
|
};
|
|
const getKeyframes = (generator, toUnit) => {
|
|
if (!keyframesCache.has(generator)) {
|
|
keyframesCache.set(generator, pregenerateKeyframes(generator, toUnit));
|
|
}
|
|
return keyframesCache.get(generator);
|
|
};
|
|
return {
|
|
createAnimation: (keyframes, shouldGenerate = true, getOrigin, name, motionValue) => {
|
|
let settings;
|
|
let origin;
|
|
let target;
|
|
let velocity = 0;
|
|
let toUnit = noopReturn;
|
|
const numKeyframes = keyframes.length;
|
|
/**
|
|
* If we should generate an animation for this value, run some preperation
|
|
* like resolving target/origin, finding a unit (if any) and determine if
|
|
* it is actually possible to generate.
|
|
*/
|
|
if (shouldGenerate) {
|
|
toUnit = getUnitConverter(keyframes, name ? transformDefinitions.get(getStyleName(name)) : undefined);
|
|
const targetDefinition = keyframes[numKeyframes - 1];
|
|
target = getAsNumber(targetDefinition);
|
|
if (numKeyframes > 1 && keyframes[0] !== null) {
|
|
/**
|
|
* If we have multiple keyframes, take the initial keyframe as the origin.
|
|
*/
|
|
origin = getAsNumber(keyframes[0]);
|
|
}
|
|
else {
|
|
const prevGenerator = motionValue === null || motionValue === void 0 ? void 0 : motionValue.generator;
|
|
/**
|
|
* If we have an existing generator for this value we can use it to resolve
|
|
* the animation's current value and velocity.
|
|
*/
|
|
if (prevGenerator) {
|
|
/**
|
|
* If we have a generator for this value we can use it to resolve
|
|
* the animations's current value and velocity.
|
|
*/
|
|
const { animation, generatorStartTime } = motionValue;
|
|
const startTime = (animation === null || animation === void 0 ? void 0 : animation.startTime) || generatorStartTime || 0;
|
|
const currentTime = (animation === null || animation === void 0 ? void 0 : animation.currentTime) || performance.now() - startTime;
|
|
const prevGeneratorCurrent = prevGenerator(currentTime).current;
|
|
origin = prevGeneratorCurrent;
|
|
velocity = calcGeneratorVelocity((t) => prevGenerator(t).current, currentTime, prevGeneratorCurrent);
|
|
}
|
|
else if (getOrigin) {
|
|
/**
|
|
* As a last resort, read the origin from the DOM.
|
|
*/
|
|
origin = getAsNumber(getOrigin());
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* If we've determined it is possible to generate an animation, do so.
|
|
*/
|
|
if (canGenerate(origin) && canGenerate(target)) {
|
|
const generator = getGenerator(origin, target, velocity, name === null || name === void 0 ? void 0 : name.includes("scale"));
|
|
settings = Object.assign(Object.assign({}, getKeyframes(generator, toUnit)), { easing: "linear" });
|
|
// TODO Add test for this
|
|
if (motionValue) {
|
|
motionValue.generator = generator;
|
|
motionValue.generatorStartTime = performance.now();
|
|
}
|
|
}
|
|
/**
|
|
* If by now we haven't generated a set of keyframes, create a generic generator
|
|
* based on the provided props that animates from 0-100 to fetch a rough
|
|
* "overshootDuration" - the moment when the generator first hits the animation target.
|
|
* Then return animation settings that will run a normal animation for that duration.
|
|
*/
|
|
if (!settings) {
|
|
const keyframesMetadata = getKeyframes(getGenerator(0, 100));
|
|
settings = {
|
|
easing: "ease",
|
|
duration: keyframesMetadata.overshootDuration,
|
|
};
|
|
}
|
|
return settings;
|
|
},
|
|
};
|
|
};
|
|
}
|
|
//# sourceMappingURL=create-generator-easing.js.map
|