motion 10.1.3 → 10.3.0

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

@@ -4,13 +4,11 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var defaults = require('../dom/utils/defaults.cjs.js');
 var easing = require('../dom/utils/easing.cjs.js');
-var getFunction = require('./easing/get-function.cjs.js');
+var getFunction = require('./easing/utils/get-function.cjs.js');
 var interpolate = require('./utils/interpolate.cjs.js');
 
-class Animation {
-    constructor(output, keyframes, 
-    // TODO Merge in defaults
-    { easing: easing$1 = defaults.defaults.easing, duration = defaults.defaults.duration, delay = defaults.defaults.delay, endDelay = defaults.defaults.endDelay, offset, repeat = defaults.defaults.repeat, direction = "normal", }) {
+class NumberAnimation {
+    constructor(output, keyframes = [0, 1], { easing: easing$1 = defaults.defaults.easing, duration = defaults.defaults.duration, delay = defaults.defaults.delay, endDelay = defaults.defaults.endDelay, repeat = defaults.defaults.repeat, offset, direction = "normal", } = {}) {
         this.startTime = 0;
         this.rate = 1;
         this.t = 0;
@@ -21,50 +19,69 @@ class Animation {
             this.reject = reject;
         });
         const totalDuration = duration * (repeat + 1);
+        /**
+         * 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 (easing.isCustomEasing(easing$1))
+            easing$1 = "ease";
         const interpolate$1 = interpolate.slowInterpolateNumbers(keyframes, offset, easing.isEasingList(easing$1)
             ? easing$1.map(getFunction.getEasingFunction)
             : getFunction.getEasingFunction(easing$1));
         this.tick = (timestamp) => {
-            if (this.playState === "finished") {
-                const latest = interpolate$1(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$1(interpolationProgress);
+            const latest = interpolate$1(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);
             }
@@ -123,9 +140,5 @@ class Animation {
         this.rate = rate;
     }
 }
-function animateNumber(output, keyframes = [0, 1], options = {}) {
-    return new Animation(output, keyframes, options);
-}
 
-exports.Animation = Animation;
-exports.animateNumber = animateNumber;
+exports.NumberAnimation = NumberAnimation;

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

@@ -1,12 +1,10 @@
 import { defaults } from '../dom/utils/defaults.es.js';
-import { isEasingList } from '../dom/utils/easing.es.js';
-import { getEasingFunction } from './easing/get-function.es.js';
+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, 
-    // TODO Merge in defaults
-    { easing = defaults.easing, duration = defaults.duration, delay = defaults.delay, endDelay = defaults.endDelay, offset, repeat = defaults.repeat, 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;
@@ -17,50 +15,69 @@ class Animation {
             this.reject = reject;
         });
         const totalDuration = duration * (repeat + 1);
+        /**
+         * 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);
             }
@@ -119,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

@@ -0,0 +1,64 @@
+'use strict';
+
+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;
+const defaultMass = 1.0;
+const calcDampingRatio = (stiffness = defaultStiffness, damping = defaultDamping, mass = defaultMass) => damping / (2 * Math.sqrt(stiffness * mass));
+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 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)
+        resolveSpring = (t) => to -
+            Math.exp(-dampingRatio * undampedAngularFreq * t) *
+                (((-velocity + dampingRatio * undampedAngularFreq * initialDelta) /
+                    angularFreq) *
+                    Math.sin(angularFreq * t) +
+                    initialDelta * Math.cos(angularFreq * t));
+    }
+    else {
+        // Critically damped spring
+        resolveSpring = (t) => to -
+            Math.exp(-undampedAngularFreq * t) *
+                (initialDelta + (velocity + undampedAngularFreq * initialDelta) * t);
+    }
+    return {
+        next: (t) => {
+            state.value = resolveSpring(t);
+            state.velocity =
+                t === 0 ? velocity : calcVelocity(resolveSpring, t, state.value);
+            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;
+        },
+    };
+};
+const sampleT = 5; // ms
+function calcVelocity(resolveValue, t, current) {
+    const prevT = Math.max(t - sampleT, 0);
+    return velocityPerSecond.velocityPerSecond(current - resolveValue(prevT), 5);
+}
+
+exports.calcAngularFreq = calcAngularFreq;
+exports.calcDampingRatio = calcDampingRatio;
+exports.calcVelocity = calcVelocity;
+exports.createSpringGenerator = createSpringGenerator;

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

@@ -0,0 +1,57 @@
+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;
+const defaultMass = 1.0;
+const calcDampingRatio = (stiffness = defaultStiffness, damping = defaultDamping, mass = defaultMass) => damping / (2 * Math.sqrt(stiffness * mass));
+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 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)
+        resolveSpring = (t) => to -
+            Math.exp(-dampingRatio * undampedAngularFreq * t) *
+                (((-velocity + dampingRatio * undampedAngularFreq * initialDelta) /
+                    angularFreq) *
+                    Math.sin(angularFreq * t) +
+                    initialDelta * Math.cos(angularFreq * t));
+    }
+    else {
+        // Critically damped spring
+        resolveSpring = (t) => to -
+            Math.exp(-undampedAngularFreq * t) *
+                (initialDelta + (velocity + undampedAngularFreq * initialDelta) * t);
+    }
+    return {
+        next: (t) => {
+            state.value = resolveSpring(t);
+            state.velocity =
+                t === 0 ? velocity : calcVelocity(resolveSpring, t, state.value);
+            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;
+        },
+    };
+};
+const sampleT = 5; // ms
+function calcVelocity(resolveValue, t, current) {
+    const prevT = Math.max(t - sampleT, 0);
+    return velocityPerSecond(current - resolveValue(prevT), 5);
+}
+
+export { calcAngularFreq, calcDampingRatio, calcVelocity, createSpringGenerator };

package/dist/targets/js/easing/spring/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 spring = createGeneratorEasing.createGeneratorEasing(generator.createSpringGenerator);
+
+exports.spring = spring;

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

@@ -0,0 +1,6 @@
+import { createSpringGenerator } from './generator.es.js';
+import { createGeneratorEasing } from '../utils/create-generator-easing.es.js';
+
+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;