Updated charted DEP to 0.4.X

packages/charted/lib/selection/src/transition_impl.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.selection.transition;
 
 // handle transitions on an element-basis, so we can cancel if another is
 // scheduled
 Map<Element, int> _transitionMap = {};
 
 class _TransitionImpl implements Transition {
   SelectionCallback _delay = (d, i, c) => 0;
-  SelectionCallback _duration = (d, i, c) =>
-      Transition.defaultDurationMilliseconds;
+  SelectionCallback _duration =
+      (d, i, c) => Transition.defaultDurationMilliseconds;
   Selection _selection;
   Map _attrs = {};
   Map _styles = {};
   Map _attrTweens = {};
   Map _styleTweens = {};
   Map<AnimationTimer, Element> _timerMap = {};
-  Map<Element, List<Map>> _attrMap = {};
+  Map<Element, List<Interpolator>> _attrMap = {};
   Map<Element, int> _durationMap = {};
   bool _interrupted = false;
   bool _remove = false;
   var _timerDelay = 0;
 
   _TransitionImpl(this._selection, [num delay = 0]) {
     _transitionNode(delay);
     _timerDelay = delay;
   }
 
@@ skipping 40 matching lines @@
   void styleTween(String property, StyleTweenCallback tween,
       [String priority]) {
     _styleTweens[property] = {'callback': tween, 'priority': priority};
   }
 
   // Starts a timer that registers all attributes, durations, and delays for the
   // transition of the current selection.
   _transitionNode(num delay) {
     new AnimationTimer((elapsed) {
       _selection.each((d, i, c) {
-        var tweenList = [];
+        var tweenList = <Interpolator>[];
         _attrs.forEach((key, value) {
           tweenList.add(_getAttrInterpolator(c, key, value(d, i, c)));
         });
         _attrTweens.forEach((key, value) {
           tweenList.add(
               (t) => c.setAttribute(key, value(d, i, c.getAttribute(key))(t)));
         });
         _styles.forEach((key, value) {
           tweenList.add(_getStyleInterpolator(
               c, key, value['callback'](d, i, c), value['priority']));
@@ skipping 14 matching lines @@
           _transitionMap[c] = 1;
         } else {
           _transitionMap[c]++;
         }
       });
       return true;
     }, delay: delay);
   }
 
   // Returns the correct interpolator function for the old and new attribute.
-  _getAttrInterpolator(Element element, String attrName, newValue) {
+  Interpolator _getAttrInterpolator(
+      Element element, String attrName, newValue) {
     var attr = element.attributes[attrName];
     var interpolator = createStringInterpolator(attr, newValue.toString());
     return (t) => element.setAttribute(attrName, interpolator(t).toString());
   }
 
   // Returns the correct interpolator function for the old and new style.
-  _getStyleInterpolator(Element element, String styleName, newValue, priority) {
+  Interpolator _getStyleInterpolator(
+      Element element, String styleName, newValue, priority) {
     var style = element.style.getPropertyValue(styleName);
 
     var interpolator = createStringInterpolator(style, newValue.toString());
 
     return (t) => element.style
         .setProperty(styleName, interpolator(t).toString(), priority);
   }
 
   // Ticks of the transition, this is the callback registered to the
   // ChartedTimer, called on each animation frame until the transition duration
   // has been reached.
-  bool _tick(elapsed) {
+  bool _tick(int elapsed) {
     if (_interrupted) {
       return true;
     }
     var activeNode = _timerMap[AnimationTimer.active];
     var t = elapsed / _durationMap[activeNode];
     for (Interpolator tween in _attrMap[activeNode]) {
       tween(ease(t));
     }
 
     if (t >= 1) {
@@ skipping 42 matching lines @@
     var t = new _TransitionImpl(_selection, delay);
     t.ease = ease;
     t.durationWithCallback(_duration);
     return t;
   }
 
   void remove() {
     _remove = true;
   }
 }