motion 10.2.1 → 10.3.0

package/dist/targets/js/{animate-number.es.js → NumberAnimation.es.js}

@@ -3,8 +3,8 @@ import { isCustomEasing, isEasingList } from '../dom/utils/easing.es.js';
 import { getEasingFunction } from './easing/utils/get-function.es.js';
 import { slowInterpolateNumbers } from './utils/interpolate.es.js';
 
-class Animation {
-    constructor(output, keyframes, { easing = defaults.easing, duration = defaults.duration, delay = defaults.delay, endDelay = defaults.endDelay, repeat = defaults.repeat, offset, direction = "normal", }) {
+class NumberAnimation {
+    constructor(output, keyframes = [0, 1], { easing = defaults.easing, duration = defaults.duration, delay = defaults.delay, endDelay = defaults.endDelay, repeat = defaults.repeat, offset, direction = "normal", } = {}) {
         this.startTime = 0;
         this.rate = 1;
         this.t = 0;
@@ -15,54 +15,69 @@ class Animation {
             this.reject = reject;
         });
         const totalDuration = duration * (repeat + 1);
-        // TODO: This isn't currently supported but keeps TypeScript happy
-        if (isCustomEasing(easing)) {
+        /**
+         * We don't currently support custom easing (spring, glide etc) in NumberAnimation
+         * (although this is completely possible), so this will have been hydrated by
+         * animateStyle.
+         */
+        if (isCustomEasing(easing))
             easing = "ease";
-        }
         const interpolate = slowInterpolateNumbers(keyframes, offset, isEasingList(easing)
             ? easing.map(getEasingFunction)
             : getEasingFunction(easing));
         this.tick = (timestamp) => {
-            if (this.playState === "finished") {
-                const latest = interpolate(1);
-                output(latest);
-                this.resolve(latest);
-                return;
-            }
-            if (this.pauseTime) {
+            if (this.pauseTime)
                 timestamp = this.pauseTime;
-            }
             let t = (timestamp - this.startTime) * this.rate;
             this.t = t;
             // Convert to seconds
             t /= 1000;
             // Rebase on delay
             t = Math.max(t - delay, 0);
+            /**
+             * If this animation has finished, set the current time
+             * to the total duration.
+             */
+            if (this.playState === "finished")
+                t = totalDuration;
+            /**
+             * Get the current progress (0-1) of the animation. If t is >
+             * than duration we'll get values like 2.5 (midway through the
+             * third iteration)
+             */
             const progress = t / duration;
             // TODO progress += iterationStart
+            /**
+             * Get the current iteration (0 indexed). For instance the floor of
+             * 2.5 is 2.
+             */
             let currentIteration = Math.floor(progress);
+            /**
+             * Get the current progress of the iteration by taking the remainder
+             * so 2.5 is 0.5 through iteration 2
+             */
             let iterationProgress = progress % 1.0;
             if (!iterationProgress && progress >= 1) {
                 iterationProgress = 1;
             }
-            if (iterationProgress === 1) {
-                currentIteration--;
-            }
-            // Reverse progress
+            /**
+             * If iteration progress is 1 we count that as the end
+             * of the previous iteration.
+             */
+            iterationProgress === 1 && currentIteration--;
+            /**
+             * Reverse progress if we're not running in "normal" direction
+             */
             const iterationIsOdd = currentIteration % 2;
             if (direction === "reverse" ||
                 (direction === "alternate" && iterationIsOdd) ||
                 (direction === "alternate-reverse" && !iterationIsOdd)) {
                 iterationProgress = 1 - iterationProgress;
             }
-            const interpolationIsFinished = t >= totalDuration;
-            const interpolationProgress = interpolationIsFinished
-                ? 1
-                : Math.min(iterationProgress, 1);
-            const latest = interpolate(interpolationProgress);
+            const latest = interpolate(t >= totalDuration ? 1 : Math.min(iterationProgress, 1));
             output(latest);
-            const isFinished = t >= totalDuration + endDelay;
-            if (isFinished) {
+            const isAnimationFinished = this.playState === "finished" || t >= totalDuration + endDelay;
+            if (isAnimationFinished) {
                 this.playState = "finished";
                 this.resolve(latest);
             }
@@ -121,8 +136,5 @@ class Animation {
         this.rate = rate;
     }
 }
-function animateNumber(output, keyframes = [0, 1], options = {}) {
-    return new Animation(output, keyframes, options);
-}
 
-export { Animation, animateNumber };
+export { NumberAnimation };

package/dist/targets/js/easing/glide/generator.cjs.js

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var generator = require('../spring/generator.cjs.js');
+var time = require('../../../dom/utils/time.cjs.js');
+
+const createGlideGenerator = ({ from = 0, velocity = 0.0, power = 0.8, decay = 0.325, bounceDamping, bounceStiffness, changeTarget, min, max, restDistance = 0.5, restSpeed, }) => {
+    decay = time.ms(decay);
+    const state = {
+        value: from,
+        target: from,
+        velocity,
+        hasReachedTarget: false,
+        done: false,
+    };
+    const isOutOfBounds = (v) => (min !== undefined && v < min) || (max !== undefined && v > max);
+    const nearestBoundary = (v) => {
+        if (min === undefined)
+            return max;
+        if (max === undefined)
+            return min;
+        return Math.abs(min - v) < Math.abs(max - v) ? min : max;
+    };
+    let amplitude = power * velocity;
+    const ideal = from + amplitude;
+    const target = changeTarget === undefined ? ideal : changeTarget(ideal);
+    state.target = target;
+    /**
+     * If the target has changed we need to re-calculate the amplitude, otherwise
+     * the animation will start from the wrong position.
+     */
+    if (target !== ideal)
+        amplitude = target - from;
+    const calcDelta = (t) => -amplitude * Math.exp(-t / decay);
+    const calcLatest = (t) => target + calcDelta(t);
+    const applyFriction = (t) => {
+        const delta = calcDelta(t);
+        const latest = calcLatest(t);
+        state.done = Math.abs(delta) <= restDistance;
+        state.value = state.done ? target : latest;
+        state.velocity =
+            t === 0 ? velocity : generator.calcVelocity(calcLatest, t, state.value);
+    };
+    /**
+     * Ideally this would resolve for t in a stateless way, we could
+     * do that by always precalculating the animation but as we know
+     * this will be done anyway we can assume that spring will
+     * be discovered during that.
+     */
+    let timeReachedBoundary;
+    let spring;
+    const checkCatchBoundary = (t) => {
+        if (!isOutOfBounds(state.value))
+            return;
+        timeReachedBoundary = t;
+        spring = generator.createSpringGenerator({
+            from: state.value,
+            to: nearestBoundary(state.value),
+            velocity: state.velocity,
+            damping: bounceDamping,
+            stiffness: bounceStiffness,
+            restDistance,
+            restSpeed,
+        });
+    };
+    checkCatchBoundary(0);
+    return {
+        next: (t) => {
+            /**
+             * We need to resolve the friction to figure out if we need a
+             * spring but we don't want to do this twice per frame. So here
+             * we flag if we updated for this frame and later if we did
+             * we can skip doing it again.
+             */
+            let hasUpdatedFrame = false;
+            if (!spring && timeReachedBoundary === undefined) {
+                hasUpdatedFrame = true;
+                applyFriction(t);
+                checkCatchBoundary(t);
+            }
+            /**
+             * If we have a spring and the provided t is beyond the moment the friction
+             * animation crossed the min/max boundary, use the spring.
+             */
+            if (timeReachedBoundary !== undefined && t > timeReachedBoundary) {
+                state.hasReachedTarget = true;
+                return spring.next(t - timeReachedBoundary);
+            }
+            else {
+                state.hasReachedTarget = false;
+                !hasUpdatedFrame && applyFriction(t);
+                return state;
+            }
+        },
+    };
+};
+
+exports.createGlideGenerator = createGlideGenerator;

package/dist/targets/js/easing/glide/generator.es.js

@@ -0,0 +1,95 @@
+import { calcVelocity, createSpringGenerator } from '../spring/generator.es.js';
+import { ms } from '../../../dom/utils/time.es.js';
+
+const createGlideGenerator = ({ from = 0, velocity = 0.0, power = 0.8, decay = 0.325, bounceDamping, bounceStiffness, changeTarget, min, max, restDistance = 0.5, restSpeed, }) => {
+    decay = ms(decay);
+    const state = {
+        value: from,
+        target: from,
+        velocity,
+        hasReachedTarget: false,
+        done: false,
+    };
+    const isOutOfBounds = (v) => (min !== undefined && v < min) || (max !== undefined && v > max);
+    const nearestBoundary = (v) => {
+        if (min === undefined)
+            return max;
+        if (max === undefined)
+            return min;
+        return Math.abs(min - v) < Math.abs(max - v) ? min : max;
+    };
+    let amplitude = power * velocity;
+    const ideal = from + amplitude;
+    const target = changeTarget === undefined ? ideal : changeTarget(ideal);
+    state.target = target;
+    /**
+     * If the target has changed we need to re-calculate the amplitude, otherwise
+     * the animation will start from the wrong position.
+     */
+    if (target !== ideal)
+        amplitude = target - from;
+    const calcDelta = (t) => -amplitude * Math.exp(-t / decay);
+    const calcLatest = (t) => target + calcDelta(t);
+    const applyFriction = (t) => {
+        const delta = calcDelta(t);
+        const latest = calcLatest(t);
+        state.done = Math.abs(delta) <= restDistance;
+        state.value = state.done ? target : latest;
+        state.velocity =
+            t === 0 ? velocity : calcVelocity(calcLatest, t, state.value);
+    };
+    /**
+     * Ideally this would resolve for t in a stateless way, we could
+     * do that by always precalculating the animation but as we know
+     * this will be done anyway we can assume that spring will
+     * be discovered during that.
+     */
+    let timeReachedBoundary;
+    let spring;
+    const checkCatchBoundary = (t) => {
+        if (!isOutOfBounds(state.value))
+            return;
+        timeReachedBoundary = t;
+        spring = createSpringGenerator({
+            from: state.value,
+            to: nearestBoundary(state.value),
+            velocity: state.velocity,
+            damping: bounceDamping,
+            stiffness: bounceStiffness,
+            restDistance,
+            restSpeed,
+        });
+    };
+    checkCatchBoundary(0);
+    return {
+        next: (t) => {
+            /**
+             * We need to resolve the friction to figure out if we need a
+             * spring but we don't want to do this twice per frame. So here
+             * we flag if we updated for this frame and later if we did
+             * we can skip doing it again.
+             */
+            let hasUpdatedFrame = false;
+            if (!spring && timeReachedBoundary === undefined) {
+                hasUpdatedFrame = true;
+                applyFriction(t);
+                checkCatchBoundary(t);
+            }
+            /**
+             * If we have a spring and the provided t is beyond the moment the friction
+             * animation crossed the min/max boundary, use the spring.
+             */
+            if (timeReachedBoundary !== undefined && t > timeReachedBoundary) {
+                state.hasReachedTarget = true;
+                return spring.next(t - timeReachedBoundary);
+            }
+            else {
+                state.hasReachedTarget = false;
+                !hasUpdatedFrame && applyFriction(t);
+                return state;
+            }
+        },
+    };
+};
+
+export { createGlideGenerator };

package/dist/targets/js/easing/glide/index.cjs.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var generator = require('./generator.cjs.js');
+var createGeneratorEasing = require('../utils/create-generator-easing.cjs.js');
+
+const glide = createGeneratorEasing.createGeneratorEasing(generator.createGlideGenerator);
+
+exports.glide = glide;

package/dist/targets/js/easing/glide/index.es.js

@@ -0,0 +1,6 @@
+import { createGlideGenerator } from './generator.es.js';
+import { createGeneratorEasing } from '../utils/create-generator-easing.es.js';
+
+const glide = createGeneratorEasing(createGlideGenerator);
+
+export { glide };

package/dist/targets/js/easing/spring/generator.cjs.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var velocityPerSecond = require('../../../../utils/velocity-per-second.cjs.js');
+var hasReachedTarget = require('../utils/has-reached-target.cjs.js');
 
 const defaultStiffness = 100.0;
 const defaultDamping = 10.0;
@@ -11,15 +12,17 @@ const calcDampingRatio = (stiffness = defaultStiffness, damping = defaultDamping
 const calcAngularFreq = (undampedFreq, dampingRatio) => undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);
 const createSpringGenerator = ({ stiffness = defaultStiffness, damping = defaultDamping, mass = defaultMass, from = 0, to = 1, velocity = 0.0, restSpeed = 2, restDistance = 0.5, } = {}) => {
     velocity = velocity ? velocity / 1000 : 0.0;
-    const dampingRatio = calcDampingRatio(stiffness, damping, mass);
-    const initialDelta = to - from;
-    const undampedAngularFreq = Math.sqrt(stiffness / mass) / 1000;
-    const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);
     const state = {
         done: false,
         value: from,
+        target: to,
         velocity,
+        hasReachedTarget: false,
     };
+    const dampingRatio = calcDampingRatio(stiffness, damping, mass);
+    const initialDelta = to - from;
+    const undampedAngularFreq = Math.sqrt(stiffness / mass) / 1000;
+    const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);
     let resolveSpring;
     if (dampingRatio < 1) {
         // Underdamped spring (bouncy)
@@ -44,6 +47,7 @@ const createSpringGenerator = ({ stiffness = defaultStiffness, damping = default
             const isBelowVelocityThreshold = Math.abs(state.velocity) <= restSpeed;
             const isBelowDisplacementThreshold = Math.abs(to - state.value) <= restDistance;
             state.done = isBelowVelocityThreshold && isBelowDisplacementThreshold;
+            state.hasReachedTarget = hasReachedTarget.hasReachedTarget(from, to, state.value);
             return state;
         },
     };
@@ -56,4 +60,5 @@ function calcVelocity(resolveValue, t, current) {
 
 exports.calcAngularFreq = calcAngularFreq;
 exports.calcDampingRatio = calcDampingRatio;
+exports.calcVelocity = calcVelocity;
 exports.createSpringGenerator = createSpringGenerator;

package/dist/targets/js/easing/spring/generator.es.js

@@ -1,4 +1,5 @@
 import { velocityPerSecond } from '../../../../utils/velocity-per-second.es.js';
+import { hasReachedTarget } from '../utils/has-reached-target.es.js';
 
 const defaultStiffness = 100.0;
 const defaultDamping = 10.0;
@@ -7,15 +8,17 @@ const calcDampingRatio = (stiffness = defaultStiffness, damping = defaultDamping
 const calcAngularFreq = (undampedFreq, dampingRatio) => undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);
 const createSpringGenerator = ({ stiffness = defaultStiffness, damping = defaultDamping, mass = defaultMass, from = 0, to = 1, velocity = 0.0, restSpeed = 2, restDistance = 0.5, } = {}) => {
     velocity = velocity ? velocity / 1000 : 0.0;
-    const dampingRatio = calcDampingRatio(stiffness, damping, mass);
-    const initialDelta = to - from;
-    const undampedAngularFreq = Math.sqrt(stiffness / mass) / 1000;
-    const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);
     const state = {
         done: false,
         value: from,
+        target: to,
         velocity,
+        hasReachedTarget: false,
     };
+    const dampingRatio = calcDampingRatio(stiffness, damping, mass);
+    const initialDelta = to - from;
+    const undampedAngularFreq = Math.sqrt(stiffness / mass) / 1000;
+    const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);
     let resolveSpring;
     if (dampingRatio < 1) {
         // Underdamped spring (bouncy)
@@ -40,6 +43,7 @@ const createSpringGenerator = ({ stiffness = defaultStiffness, damping = default
             const isBelowVelocityThreshold = Math.abs(state.velocity) <= restSpeed;
             const isBelowDisplacementThreshold = Math.abs(to - state.value) <= restDistance;
             state.done = isBelowVelocityThreshold && isBelowDisplacementThreshold;
+            state.hasReachedTarget = hasReachedTarget(from, to, state.value);
             return state;
         },
     };
@@ -50,4 +54,4 @@ function calcVelocity(resolveValue, t, current) {
     return velocityPerSecond(current - resolveValue(prevT), 5);
 }
 
-export { calcAngularFreq, calcDampingRatio, createSpringGenerator };
+export { calcAngularFreq, calcDampingRatio, calcVelocity, createSpringGenerator };

package/dist/targets/js/easing/spring/index.cjs.js

@@ -3,68 +3,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var generator = require('./generator.cjs.js');
-var pregenerateKeyframes = require('../utils/pregenerate-keyframes.cjs.js');
+var createGeneratorEasing = require('../utils/create-generator-easing.cjs.js');
 
-function spring(options = {}) {
-    const springCache = new Map();
-    const keyframesCache = new WeakMap();
-    const getSpring = (from = 0, to = 100, velocity = 0, isScale = false) => {
-        const key = `${from}-${to}-${velocity}-${isScale}`;
-        if (!springCache.has(key)) {
-            springCache.set(key, generator.createSpringGenerator(Object.assign({ from,
-                to,
-                velocity, restSpeed: isScale ? 0.05 : 2, restDistance: isScale ? 0.01 : 0.5 }, options)));
-        }
-        return springCache.get(key);
-    };
-    const getKeyframes = (generator, origin, target) => {
-        if (!keyframesCache.has(generator)) {
-            keyframesCache.set(generator, pregenerateKeyframes.pregenerateKeyframes(generator, origin, target));
-        }
-        return keyframesCache.get(generator);
-    };
-    return {
-        createAnimation: (keyframes, getOrigin, canUseRealSpring, name, data) => {
-            let settings;
-            let spring;
-            const numKeyframes = keyframes.length;
-            let shouldUseRealSpring = canUseRealSpring && numKeyframes <= 2 && keyframes.every(isNumberOrNull);
-            if (shouldUseRealSpring) {
-                const prevAnimationState = name && data && getPreviousAnimationState(name, data);
-                const velocity = prevAnimationState &&
-                    (numKeyframes === 1 || (numKeyframes === 2 && keyframes[0] === null))
-                    ? prevAnimationState.velocity
-                    : 0;
-                const target = keyframes[numKeyframes - 1];
-                const unresolvedOrigin = numKeyframes === 1 ? null : keyframes[0];
-                const origin = unresolvedOrigin === null
-                    ? prevAnimationState
-                        ? prevAnimationState.value
-                        : parseFloat(getOrigin())
-                    : unresolvedOrigin;
-                spring = getSpring(origin, target, velocity, name === null || name === void 0 ? void 0 : name.includes("scale"));
-                const keyframesMetadata = getKeyframes(spring, origin, target);
-                settings = Object.assign(Object.assign({}, keyframesMetadata), { easing: "linear" });
-            }
-            else {
-                spring = getSpring(0, 100);
-                const keyframesMetadata = getKeyframes(spring, 0, 100);
-                settings = {
-                    easing: "ease",
-                    duration: keyframesMetadata.overshootDuration,
-                };
-            }
-            return settings;
-        },
-    };
-}
-function getPreviousAnimationState(name, data) {
-    const animation = data.activeAnimations[name];
-    const generator = data.activeGenerators[name];
-    if (animation && generator) {
-        return generator.next(animation.currentTime);
-    }
-}
-const isNumberOrNull = (value) => typeof value !== "string";
+const spring = createGeneratorEasing.createGeneratorEasing(generator.createSpringGenerator);
 
 exports.spring = spring;

package/dist/targets/js/easing/spring/index.es.js

@@ -1,66 +1,6 @@
 import { createSpringGenerator } from './generator.es.js';
-import { pregenerateKeyframes } from '../utils/pregenerate-keyframes.es.js';
+import { createGeneratorEasing } from '../utils/create-generator-easing.es.js';
 
-function spring(options = {}) {
-    const springCache = new Map();
-    const keyframesCache = new WeakMap();
-    const getSpring = (from = 0, to = 100, velocity = 0, isScale = false) => {
-        const key = `${from}-${to}-${velocity}-${isScale}`;
-        if (!springCache.has(key)) {
-            springCache.set(key, createSpringGenerator(Object.assign({ from,
-                to,
-                velocity, restSpeed: isScale ? 0.05 : 2, restDistance: isScale ? 0.01 : 0.5 }, options)));
-        }
-        return springCache.get(key);
-    };
-    const getKeyframes = (generator, origin, target) => {
-        if (!keyframesCache.has(generator)) {
-            keyframesCache.set(generator, pregenerateKeyframes(generator, origin, target));
-        }
-        return keyframesCache.get(generator);
-    };
-    return {
-        createAnimation: (keyframes, getOrigin, canUseRealSpring, name, data) => {
-            let settings;
-            let spring;
-            const numKeyframes = keyframes.length;
-            let shouldUseRealSpring = canUseRealSpring && numKeyframes <= 2 && keyframes.every(isNumberOrNull);
-            if (shouldUseRealSpring) {
-                const prevAnimationState = name && data && getPreviousAnimationState(name, data);
-                const velocity = prevAnimationState &&
-                    (numKeyframes === 1 || (numKeyframes === 2 && keyframes[0] === null))
-                    ? prevAnimationState.velocity
-                    : 0;
-                const target = keyframes[numKeyframes - 1];
-                const unresolvedOrigin = numKeyframes === 1 ? null : keyframes[0];
-                const origin = unresolvedOrigin === null
-                    ? prevAnimationState
-                        ? prevAnimationState.value
-                        : parseFloat(getOrigin())
-                    : unresolvedOrigin;
-                spring = getSpring(origin, target, velocity, name === null || name === void 0 ? void 0 : name.includes("scale"));
-                const keyframesMetadata = getKeyframes(spring, origin, target);
-                settings = Object.assign(Object.assign({}, keyframesMetadata), { easing: "linear" });
-            }
-            else {
-                spring = getSpring(0, 100);
-                const keyframesMetadata = getKeyframes(spring, 0, 100);
-                settings = {
-                    easing: "ease",
-                    duration: keyframesMetadata.overshootDuration,
-                };
-            }
-            return settings;
-        },
-    };
-}
-function getPreviousAnimationState(name, data) {
-    const animation = data.activeAnimations[name];
-    const generator = data.activeGenerators[name];
-    if (animation && generator) {
-        return generator.next(animation.currentTime);
-    }
-}
-const isNumberOrNull = (value) => typeof value !== "string";
+const spring = createGeneratorEasing(createSpringGenerator);
 
 export { spring };

package/dist/targets/js/easing/utils/create-generator-easing.cjs.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var pregenerateKeyframes = require('./pregenerate-keyframes.cjs.js');
+
+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, restSpeed: isScale ? 0.05 : 2, restDistance: isScale ? 0.01 : 0.5 }, options)));
+            }
+            return generatorCache.get(key);
+        };
+        const getKeyframes = (generator) => {
+            if (!keyframesCache.has(generator)) {
+                keyframesCache.set(generator, pregenerateKeyframes.pregenerateKeyframes(generator));
+            }
+            return keyframesCache.get(generator);
+        };
+        return {
+            createAnimation: (keyframes, getOrigin, canUseGenerator, name, data) => {
+                let settings;
+                let generator;
+                const numKeyframes = keyframes.length;
+                let shouldUseGenerator = canUseGenerator &&
+                    numKeyframes <= 2 &&
+                    keyframes.every(isNumberOrNull);
+                if (shouldUseGenerator) {
+                    const prevAnimationState = name && data && data.prevGeneratorState[name];
+                    const velocity = prevAnimationState &&
+                        (numKeyframes === 1 ||
+                            (numKeyframes === 2 && keyframes[0] === null))
+                        ? prevAnimationState.velocity
+                        : 0;
+                    const target = keyframes[numKeyframes - 1];
+                    const unresolvedOrigin = numKeyframes === 1 ? null : keyframes[0];
+                    const origin = unresolvedOrigin === null
+                        ? prevAnimationState
+                            ? prevAnimationState.value
+                            : parseFloat(getOrigin())
+                        : unresolvedOrigin;
+                    generator = getGenerator(origin, target, velocity, name === null || name === void 0 ? void 0 : name.includes("scale"));
+                    const keyframesMetadata = getKeyframes(generator);
+                    settings = Object.assign(Object.assign({}, keyframesMetadata), { easing: "linear" });
+                }
+                else {
+                    generator = getGenerator(0, 100);
+                    const keyframesMetadata = getKeyframes(generator);
+                    settings = {
+                        easing: "ease",
+                        duration: keyframesMetadata.overshootDuration,
+                    };
+                }
+                // TODO Add test for this
+                if (generator && data && name) {
+                    data.generators[name] = generator;
+                }
+                return settings;
+            },
+        };
+    };
+}
+const isNumberOrNull = (value) => typeof value !== "string";
+
+exports.createGeneratorEasing = createGeneratorEasing;