ES6-animatio/common/bezier-easing.js

(function(f) {
  if (typeof exports === 'object' && typeof module !== 'undefined') {
    module.exports = f();
  } else if (typeof define === 'function' && define.amd) {
    define([], f);
  } else {
    var g;
    if (typeof window !== 'undefined') {
      g = window;
    } else if (typeof global !== 'undefined') {
      g = global;
    } else if (typeof self !== 'undefined') {
      g = self;
    } else {
      g = this;
    }
    g.BezierEasing = f();
  }
})(function() {
  var define, module, exports;
  return (function() {
    function r(e, n, t) {
      function o(i, f) {
        if (!n[i]) {
          if (!e[i]) {
            var c = 'function' == typeof require && require;
            if (!f && c) return c(i, !0);
            if (u) return u(i, !0);
            var a = new Error("Cannot find module '" + i + "'");
            throw ((a.code = 'MODULE_NOT_FOUND'), a);
          }
          var p = (n[i] = { exports: {} });
          e[i][0].call(
            p.exports,
            function(r) {
              var n = e[i][1][r];
              return o(n || r);
            },
            p,
            p.exports,
            r,
            e,
            n,
            t
          );
        }
        return n[i].exports;
      }
      for (var u = 'function' == typeof require && require, i = 0; i < t.length; i++) o(t[i]);
      return o;
    }
    return r;
  })()(
    {
      1: [
        function(require, module, exports) {
          /**
           * https://github.com/gre/bezier-easing
           * BezierEasing - use bezier curve for transition easing function
           * by Gaëtan Renaudeau 2014 - 2015 – MIT License
           */

          // These values are established by empiricism with tests (tradeoff: performance VS precision)
          var NEWTON_ITERATIONS = 4;
          var NEWTON_MIN_SLOPE = 0.001;
          var SUBDIVISION_PRECISION = 0.0000001;
          var SUBDIVISION_MAX_ITERATIONS = 10;

          var kSplineTableSize = 11;
          var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);

          var float32ArraySupported = typeof Float32Array === 'function';

          function A(aA1, aA2) {
            return 1.0 - 3.0 * aA2 + 3.0 * aA1;
          }
          function B(aA1, aA2) {
            return 3.0 * aA2 - 6.0 * aA1;
          }
          function C(aA1) {
            return 3.0 * aA1;
          }

          // Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
          function calcBezier(aT, aA1, aA2) {
            return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
          }

          // Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
          function getSlope(aT, aA1, aA2) {
            return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1);
          }

          function binarySubdivide(aX, aA, aB, mX1, mX2) {
            var currentX,
              currentT,
              i = 0;
            do {
              currentT = aA + (aB - aA) / 2.0;
              currentX = calcBezier(currentT, mX1, mX2) - aX;
              if (currentX > 0.0) {
                aB = currentT;
              } else {
                aA = currentT;
              }
            } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
            return currentT;
          }

          function newtonRaphsonIterate(aX, aGuessT, mX1, mX2) {
            for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
              var currentSlope = getSlope(aGuessT, mX1, mX2);
              if (currentSlope === 0.0) {
                return aGuessT;
              }
              var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
              aGuessT -= currentX / currentSlope;
            }
            return aGuessT;
          }

          function LinearEasing(x) {
            return x;
          }

          module.exports = function bezier(mX1, mY1, mX2, mY2) {
            if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) {
              throw new Error('bezier x values must be in [0, 1] range');
            }

            if (mX1 === mY1 && mX2 === mY2) {
              return LinearEasing;
            }

            // Precompute samples table
            var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
            for (var i = 0; i < kSplineTableSize; ++i) {
              sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
            }

            function getTForX(aX) {
              var intervalStart = 0.0;
              var currentSample = 1;
              var lastSample = kSplineTableSize - 1;

              for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
                intervalStart += kSampleStepSize;
              }
              --currentSample;

              // Interpolate to provide an initial guess for t
              var dist =
                (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
              var guessForT = intervalStart + dist * kSampleStepSize;

              var initialSlope = getSlope(guessForT, mX1, mX2);
              if (initialSlope >= NEWTON_MIN_SLOPE) {
                return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
              } else if (initialSlope === 0.0) {
                return guessForT;
              } else {
                return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
              }
            }

            return function BezierEasing(x) {
              // Because JavaScript number are imprecise, we should guarantee the extremes are right.
              if (x === 0) {
                return 0;
              }
              if (x === 1) {
                return 1;
              }
              return calcBezier(getTForX(x), mY1, mY2);
            };
          };
        },
        {}
      ]
    },
    {},
    [1]
  )(1);
});