Updated charted DEP to 0.4.X

packages/charted/lib/selection/selection.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
  */
 /*
  * TODO(prsd): Document library
  */
 library charted.selection;
 
-import "dart:html" show Element, Event, document;
+import "dart:html" show Element, Event, EventListener, document;
 import "dart:math" as math;
 import "package:charted/core/utils.dart";
 import "package:charted/selection/transition.dart";
 
 part "selection_scope.dart";
 part "src/selection_impl.dart";
 
 /**
  * Callback to access key value from a given data object. During the process
  * of binding data to Elements, the key values are used to match Elements
  * that have previously bound data
  */
 typedef SelectionKeyFunction(datum);
 
 /**
  * Callback for all DOM related operations - The first parameter [datum] is
  * the piece of data associated with the node, [ei] is the index of the
  * element in it's group and [c] is the context to which the data is
  * associated to.
  */
 typedef E SelectionCallback<E>(datum, int index, Element element);
 
 /** Callback used to access a value from a datum */
 typedef E SelectionValueAccessor<E>(datum, int index);
 
 /** Create a ChartedCallback that always returns [val] */
-SelectionCallback toCallback(val) => (datum, index, element) => val;
+SelectionCallback/*<T>*/ toCallback/*<T>*/(/*=T*/ val) => (datum, index, element) => val;
 
 /** Create a ChartedValueAccessor that always returns [val] */
 SelectionValueAccessor toValueAccessor(val) => (datum, index) => val;
 
 /**
  * [Selection] is a collection of elements - this collection defines
  * operators that can be applied on all elements of the collection.
  *
  * All operators accept parameters either as a constant value or a callback
  * function (typically using the named parameters "val" and "fn"). These
  * operators, when invoked with the callback function, the function is
  * called once per element and is passed the "data" associated, the "index"
  * and the element itself.
  */
 abstract class Selection {
   /**
    * Collection of groups - A selection when created by calling [selectAll]
    * on an existing [Selection], could contain more than one group.
    */
-  Iterable<SelectionGroup> groups;
+  List<SelectionGroup> groups;
 
   /**
    * Scope of this selection that manages the element, data associations for
    * all elements in this selection (and the sub-selections)
    */
   SelectionScope get scope;
 
   /** Indicates if this selection is empty */
   bool get isEmpty;
 
@@ skipping 214 matching lines @@
    * applying instantaneously.
    */
   Transition transition();
 }
 
 /*
  * Group of elements in the selection.
  * Each selection may contain more than one group of elements.
  */
 abstract class SelectionGroup {
-  Iterable<Element> elements;
+  List<Element> elements;
   Element parent;
 }
 
 /**
  * [EnterSelection] is a sub-selection that represents missing elements of a
  * selection - an element is considered missing when there is data and no
  * corresponding element in a selection.
  */
 abstract class EnterSelection {
   /**
@@ skipping 73 matching lines @@
    * elements which weren't associated with an element in the DOM.
    */
   EnterSelection get enter;
 
   /**
    * A view of the current selection containing elements that don't have data
    * associated with them.
    */
   ExitSelection get exit;
 }