Roll Observatory deps (charted -> ^0.3.0)

packages/charted/lib/core/interpolators/easing.dart

 //
 // Copyright 2014 Google Inc. All rights reserved.
 //
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file or at
 // https://developers.google.com/open-source/licenses/bsd
 //
 
 part of charted.core.interpolators;
 
-const String EASE_TYPE_LINEAR   = 'linear';
-const String EASE_TYPE_POLY     = 'poly';
-const String EASE_TYPE_QUAD     = 'quad';
-const String EASE_TYPE_CUBIC    = 'cubic';
-const String EASE_TYPE_SIN      = 'sin';
-const String EASE_TYPE_EXP      = 'exp';
-const String EASE_TYPE_CIRCLE   = 'circle';
-const String EASE_TYPE_ELASTIC  = 'elastic';
-const String EASE_TYPE_BACK     = 'back';
-const String EASE_TYPE_BOUNCE   = 'bounce';
+const String EASE_TYPE_LINEAR = 'linear';
+const String EASE_TYPE_POLY = 'poly';
+const String EASE_TYPE_QUAD = 'quad';
+const String EASE_TYPE_CUBIC = 'cubic';
+const String EASE_TYPE_SIN = 'sin';
+const String EASE_TYPE_EXP = 'exp';
+const String EASE_TYPE_CIRCLE = 'circle';
+const String EASE_TYPE_ELASTIC = 'elastic';
+const String EASE_TYPE_BACK = 'back';
+const String EASE_TYPE_BOUNCE = 'bounce';
 
-const String EASE_MODE_IN       = 'in';
-const String EASE_MODE_OUT      = 'out';
-const String EASE_MODE_IN_OUT   = 'in-out';
-const String EASE_MODE_OUT_IN   = 'out-in';
+const String EASE_MODE_IN = 'in';
+const String EASE_MODE_OUT = 'out';
+const String EASE_MODE_IN_OUT = 'in-out';
+const String EASE_MODE_OUT_IN = 'out-in';
 
 /// [EasingFunction] manipulates progression of an animation.  The returned
 /// value is passed to an [Interpolator] to generate intermediate state.
 typedef num EasingFunction(num t);
 
 /// Alters behavior of the [EasingFunction].  Takes [fn] and returns an
 /// altered [EasingFunction].
 typedef EasingFunction EasingModeFunction(EasingFunction fn);
 
 /// Creates an easing function based on type and mode.
-EasingFunction easingFunctionByName(
-    String type, [String mode = EASE_MODE_IN, List params]) {
+EasingFunction easingFunctionByName(String type,
+    [String mode = EASE_MODE_IN, List params]) {
   const Map easingTypes = const {
     EASE_TYPE_LINEAR: identityFunction,
     EASE_TYPE_POLY: easePoly,
     EASE_TYPE_QUAD: easeQuad,
     EASE_TYPE_CUBIC: easeCubic,
     EASE_TYPE_SIN: easeSin,
     EASE_TYPE_EXP: easeExp,
     EASE_TYPE_CIRCLE: easeCircle,
     EASE_TYPE_ELASTIC: easeElastic,
     EASE_TYPE_BACK: easeBack,
     EASE_TYPE_BOUNCE: easeBounce
   };
-  
+
   const Map easingModes = const {
     EASE_MODE_IN: identityFunction,
     EASE_MODE_OUT: reverseEasingFn,
     EASE_MODE_IN_OUT: reflectEasingFn,
     EASE_MODE_OUT_IN: reflectReverseEasingFn
   };
-  
+
   const Map customEasingFunctions = const {
-    '$EASE_TYPE_CUBIC-$EASE_MODE_IN_OUT': easeCubicInOut 
+    '$EASE_TYPE_CUBIC-$EASE_MODE_IN_OUT': easeCubicInOut
   };
 
   assert(easingTypes.containsKey(type));
   assert(easingModes.containsKey(mode));
-  
+
   EasingFunction fn;
   if (customEasingFunctions.containsKey('$type-$mode')) {
     fn = Function.apply(customEasingFunctions['$type-$mode'], params);
   } else {
     fn = Function.apply(easingTypes[type], params);
     fn = easingModes[mode](fn);
   }
   return clampEasingFn(fn);
 }
 
-
 /// Clamps transition progress to stay between 0.0 and 1.0
 EasingFunction clampEasingFn(EasingFunction f) =>
     (t) => t <= 0 ? 0 : t >= 1 ? 1 : f(t);
 
-
 //
 // Implementation of easing modes.
 //
 
-EasingFunction reverseEasingFn(EasingFunction f) =>
-    (t) => 1 - f(1 - t);
+EasingFunction reverseEasingFn(EasingFunction f) => (t) => 1 - f(1 - t);
 
 EasingFunction reflectEasingFn(EasingFunction f) =>
     (t) => .5 * (t < .5 ? f(2 * t) : (2 - f(2 - 2 * t)));
 
 EasingFunction reflectReverseEasingFn(EasingFunction f) =>
     reflectEasingFn(reverseEasingFn(f));
 
-
 //
 // Implementation of easing function generators.
 //
 
 EasingFunction easePoly([e = 1]) => (t) => math.pow(t, e);
 
 EasingFunction easeElastic([a = 1, p = 0.45]) {
   var s = p / 2 * math.PI * math.asin(1 / a);
-  return (t) => 1 + a * math.pow(2, -10 * t) *
-      math.sin((t - s) * 2 * math.PI / p);
+  return (t) =>
+      1 + a * math.pow(2, -10 * t) * math.sin((t - s) * 2 * math.PI / p);
 }
 
-EasingFunction easeBack([s = 1.70158]) =>
-    (num t) => t * t * ((s + 1) * t - s);
+EasingFunction easeBack([s = 1.70158]) => (num t) => t * t * ((s + 1) * t - s);
 
 EasingFunction easeQuad() => (num t) => t * t;
 
 EasingFunction easeCubic() => (num t) => t * t * t;
 
-EasingFunction easeCubicInOut() =>
-    (num t) {
+EasingFunction easeCubicInOut() => (num t) {
       if (t <= 0) return 0;
       if (t >= 1) return 1;
-      var t2 = t * t,
-          t3 = t2 * t;
+      var t2 = t * t, t3 = t2 * t;
       return 4 * (t < .5 ? t3 : 3 * (t - t2) + t3 - .75);
     };
 
-EasingFunction easeSin() =>
-    (num t) => 1 - math.cos(t * math.PI / 2);
+EasingFunction easeSin() => (num t) => 1 - math.cos(t * math.PI / 2);
 
-EasingFunction easeExp() =>
-    (num t) => math.pow(2, 10 * (t - 1));
+EasingFunction easeExp() => (num t) => math.pow(2, 10 * (t - 1));
 
-EasingFunction easeCircle() =>
-    (num t) => 1 - math.sqrt(1 - t * t);
+EasingFunction easeCircle() => (num t) => 1 - math.sqrt(1 - t * t);
 
-EasingFunction easeBounce() =>
-    (num t) =>  t < 1 / 2.75 ?
-        7.5625 * t * t : t < 2 / 2.75 ?
-            7.5625 * (t -= 1.5 / 2.75) * t + .75 : t < 2.5 / 2.75 ?
-                7.5625 * (t -= 2.25 / 2.75) * t + .9375
-                    : 7.5625 * (t -= 2.625 / 2.75) * t + .984375;
+EasingFunction easeBounce() => (num t) => t < 1 / 2.75
+    ? 7.5625 * t * t
+    : t < 2 / 2.75
+        ? 7.5625 * (t -= 1.5 / 2.75) * t + .75
+        : t < 2.5 / 2.75
+            ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375
+            : 7.5625 * (t -= 2.625 / 2.75) * t + .984375;