Updated charted DEP to 0.4.X

packages/charted/lib/selection/src/selection_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;
 
 /**
  * Implementation of [Selection].
  * Selections cannot be created directly - they are only created using
  * the select or selectAll methods on [SelectionScope] and [Selection].
  */
 class _SelectionImpl implements Selection {
-  Iterable<SelectionGroup> groups;
+  List<SelectionGroup> groups;
   SelectionScope scope;
 
   /**
    * Creates a new selection.
    *
    * When [source] is not specified, the new selection would have exactly
    * one group with [SelectionScope.root] as it's parent.  Otherwise, one group
    * per for each non-null element is created with element as it's parent.
    *
    * When [selector] is specified, each group contains all elements matching
@@ skipping 78 matching lines @@
     } else {
       groups = new List<SelectionGroup>.generate(
           1,
           (_) => new _SelectionGroupImpl(
               new List.generate(1, (_) => fn(null, 0, null), growable: false)),
           growable: false);
     }
   }
 
   /** Creates a selection using the pre-computed list of [SelectionGroup] */
-  _SelectionImpl.selectionGroups(
-      Iterable<SelectionGroup> this.groups, SelectionScope this.scope);
+  _SelectionImpl.selectionGroups(this.groups, this.scope);
 
   /**
    * Creates a selection using the list of elements. All elements will
    * be part of the same group, with [SelectionScope.root] as the group's parent
    */
-  _SelectionImpl.elements(Iterable elements, SelectionScope this.scope) {
-    groups = new List<SelectionGroup>()..add(new _SelectionGroupImpl(elements));
+  _SelectionImpl.elements(
+      Iterable<Element> elements, SelectionScope this.scope) {
+    groups = new List<SelectionGroup>()
+      ..add(new _SelectionGroupImpl(elements.toList()));
   }
 
   /**
    * Utility to evaluate value of parameters (uses value when given
    * or invokes a callback to get the value) and calls [action] for
    * each non-null element in this selection
    */
   void _do(SelectionCallback f, Function action) {
     each((d, i, e) => action(e, f == null ? null : f(scope.datum(e), i, e)));
   }
 
   /** Calls a function on each non-null element in the selection */
   void each(SelectionCallback fn) {
     if (fn == null) return;
     for (int gi = 0, gLen = groups.length; gi < gLen; ++gi) {
       final g = groups.elementAt(gi);
       for (int ei = 0, eLen = g.elements.length; ei < eLen; ++ei) {
         final e = g.elements.elementAt(ei);
         if (e != null) fn(scope.datum(e), ei, e);
       }
     }
   }
 
   void on(String type, [SelectionCallback listener, bool capture]) {
-    Function getEventHandler(i, e) => (Event event) {
+    EventListener getEventHandler(i, e) => (Event event) {
           var previous = scope.event;
           scope.event = event;
           try {
             listener(scope.datum(e), i, e);
           } finally {
             scope.event = previous;
           }
         };
 
     if (!type.startsWith('.')) {
@@ skipping 12 matching lines @@
           if (handlers != null && handlers[type] != null) {
             e.removeEventListener(
                 type, handlers[type].first, handlers[type].last);
           }
         });
       }
     } else {
       // Remove all listeners on the event type (ignoring the namespace)
       each((d, i, Element e) {
         var handlers = scope._listeners[e], t = type.substring(1);
-        handlers.forEach((String s, Pair<Function, bool> value) {
+        handlers.forEach((String s, Pair<EventListener, bool> value) {
           if (s.split('.')[0] == t) {
             e.removeEventListener(s, value.first, value.last);
           }
         });
       });
     }
   }
 
   int get length {
     int retval = 0;
@@ skipping 82 matching lines @@
   }
 
   Selection append(String tag) {
     assert(tag != null && tag.isNotEmpty);
     return appendWithCallback(
         (d, ei, e) => Namespace.createChildElement(tag, e));
   }
 
   Selection appendWithCallback(SelectionCallback<Element> fn) {
     assert(fn != null);
-    return new _SelectionImpl.single(fn: (datum, ei, e) {
-      Element child = fn(datum, ei, e);
-      return child == null ? null : e.append(child);
-    }, source: this);
+    return new _SelectionImpl.single(
+        fn: (datum, ei, e) {
+          Element child = fn(datum, ei, e);
+          return child == null ? null : e.append(child);
+        },
+        source: this);
   }
 
   Selection insert(String tag,
       {String before, SelectionCallback<Element> beforeFn}) {
     assert(tag != null && tag.isNotEmpty);
     return insertWithCallback(
         (d, ei, e) => Namespace.createChildElement(tag, e),
         before: before,
         beforeFn: beforeFn);
   }
 
   Selection insertWithCallback(SelectionCallback<Element> fn,
       {String before, SelectionCallback<Element> beforeFn}) {
     assert(fn != null);
     beforeFn =
         before == null ? beforeFn : (d, ei, e) => e.querySelector(before);
-    return new _SelectionImpl.single(fn: (datum, ei, e) {
-      Element child = fn(datum, ei, e);
-      Element before = beforeFn(datum, ei, e);
-      return child == null ? null : e.insertBefore(child, before);
-    }, source: this);
+    return new _SelectionImpl.single(
+        fn: (datum, ei, e) {
+          Element child = fn(datum, ei, e);
+          Element before = beforeFn(datum, ei, e);
+          return child == null ? null : e.insertBefore(child, before);
+        },
+        source: this);
   }
 
   Selection selectAll(String selector) {
     assert(selector != null && selector.isNotEmpty);
     return new _SelectionImpl.all(selector: selector, source: this);
   }
 
   Selection selectAllWithCallback(SelectionCallback<Iterable<Element>> fn) {
     assert(fn != null);
     return new _SelectionImpl.all(fn: fn, source: this);
   }
 
   DataSelection data(Iterable vals, [SelectionKeyFunction keyFn]) {
     assert(vals != null);
     return dataWithCallback(toCallback(vals), keyFn);
   }
 
   DataSelection dataWithCallback(SelectionCallback<Iterable> fn,
       [SelectionKeyFunction keyFn]) {
     assert(fn != null);
 
-    var enterGroups = [], updateGroups = [], exitGroups = [];
+    var enterGroups = <SelectionGroup>[],
+        updateGroups = <SelectionGroup>[],
+        exitGroups = <SelectionGroup>[];
 
     // Create a dummy node to be used with enter() selection.
-    Object dummy(val) {
-      var element = new Object();
+    Element dummy(val) {
+      var element = new Element.div();
       scope.associate(element, val);
       return element;
     }
     ;
 
     // Joins data to all elements in the group.
     void join(SelectionGroup g, Iterable vals) {
       final int valuesLength = vals.length;
       final int elementsLength = g.elements.length;
 
       // Nodes exiting, entering and updating in this group.
       // We maintain the nodes at the same index as they currently
       // are (for exiting) or where they should be (for entering and updating)
-      var update = new List(valuesLength),
-          enter = new List(valuesLength),
-          exit = new List(elementsLength);
+      var update = new List<Element>(valuesLength);
+      var enter = new List<Element>(valuesLength);
+      var exit = new List<Element>(elementsLength);
 
       // Use key function to determine DOMElement to data associations.
       if (keyFn != null) {
         var keysOnDOM = [], elementsByKey = {}, valuesByKey = {};
 
         // Create a key to DOM element map.
         // Used later to see if an element already exists for a key.
         for (int ei = 0, len = elementsLength; ei < len; ++ei) {
           final e = g.elements.elementAt(ei);
           var keyValue = keyFn(scope.datum(e));
@@ skipping 81 matching lines @@
   }
 
   Transition transition() => new Transition(this);
 }
 
 /* Implementation of [DataSelection] */
 class _DataSelectionImpl extends _SelectionImpl implements DataSelection {
   EnterSelection enter;
   ExitSelection exit;
 
-  _DataSelectionImpl(Iterable updated, Iterable entering, Iterable exiting,
+  _DataSelectionImpl(
+      List<SelectionGroup> updated,
+      Iterable<SelectionGroup> entering,
+      Iterable<SelectionGroup> exiting,
       SelectionScope scope)
       : super.selectionGroups(updated, scope) {
     enter = new _EnterSelectionImpl(entering, this);
     exit = new _ExitSelectionImpl(exiting, this);
   }
 }
 
 /* Implementation of [EnterSelection] */
 class _EnterSelectionImpl implements EnterSelection {
   final DataSelection update;
 
   SelectionScope scope;
   Iterable<SelectionGroup> groups;
 
-  _EnterSelectionImpl(Iterable this.groups, DataSelection this.update) {
+  _EnterSelectionImpl(this.groups, this.update) {
     scope = update.scope;
   }
 
   bool get isEmpty => false;
 
   Selection insert(String tag,
       {String before, SelectionCallback<Element> beforeFn}) {
     assert(tag != null && tag.isNotEmpty);
     return insertWithCallback(
         (d, ei, e) => Namespace.createChildElement(tag, e),
@@ skipping 25 matching lines @@
       return child;
     });
   }
 
   Selection select(String selector) {
     assert(selector == null && selector.isNotEmpty);
     return selectWithCallback((d, ei, e) => e.querySelector(selector));
   }
 
   Selection selectWithCallback(SelectionCallback<Element> fn) {
-    var subgroups = [];
+    var subgroups = <SelectionGroup>[];
     for (int gi = 0, len = groups.length; gi < len; ++gi) {
       final g = groups.elementAt(gi);
       final u = update.groups.elementAt(gi);
-      final subgroup = [];
+      final subgroup = <Element>[];
       for (int ei = 0, eLen = g.elements.length; ei < eLen; ++ei) {
         final e = g.elements.elementAt(ei);
         if (e != null) {
           var datum = scope.datum(e), selected = fn(datum, ei, g.parent);
           scope.associate(selected, datum);
           u.elements[ei] = selected;
           subgroup.add(selected);
         } else {
           subgroup.add(null);
         }
       }
       subgroups.add(new _SelectionGroupImpl(subgroup, parent: g.parent));
     }
     return new _SelectionImpl.selectionGroups(subgroups, scope);
   }
 }
 
 /* Implementation of [ExitSelection] */
 class _ExitSelectionImpl extends _SelectionImpl implements ExitSelection {
   final DataSelection update;
-  _ExitSelectionImpl(Iterable groups, DataSelection update)
+  _ExitSelectionImpl(List<SelectionGroup> groups, DataSelection update)
       : update = update,
         super.selectionGroups(groups, update.scope);
 }
 
 class _SelectionGroupImpl implements SelectionGroup {
-  Iterable<Element> elements;
+  List<Element> elements;
   Element parent;
   _SelectionGroupImpl(this.elements, {this.parent});
 }