packages/charted/lib/selection/src/selection_impl.dart - observatory_pub_packages - Git at Google

 /*
  * 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 {
   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
    * [selector] and under the group's parent element.  Otherwise, [fn] is
    * called once per group with parent element's "data", "index" and the
    * "element" itself passed as parameters.  [fn] must return an iterable of
    * elements to be used in each group.
    */
   _SelectionImpl.all(
       {String selector,
       SelectionCallback<List<Element>> fn,
       SelectionScope this.scope,
       Selection source}) {
     assert(selector != null || fn != null);
     assert(source != null || scope != null);

     if (selector != null) {
       fn = (d, i, c) => c == null
           ? scope.root.querySelectorAll(selector)
           : c.querySelectorAll(selector);
     }

     var tmpGroups = new List<SelectionGroup>();
     if (source != null) {
       scope = source.scope;
       for (int gi = 0; gi < source.groups.length; ++gi) {
         final g = source.groups.elementAt(gi);
         for (int ei = 0; ei < g.elements.length; ++ei) {
           final e = g.elements.elementAt(ei);
           if (e != null) {
             tmpGroups.add(
                 new _SelectionGroupImpl(fn(scope.datum(e), gi, e), parent: e));
           }
         }
       }
     } else {
       tmpGroups
           .add(new _SelectionGroupImpl(fn(null, 0, null), parent: scope.root));
     }
     groups = tmpGroups;
   }

   /**
    * Same as [all] but only uses the first element matching [selector] when
    * [selector] is specified.  Otherwise, call [fn] which must return the
    * element to be selected.
    */
   _SelectionImpl.single(
       {String selector,
       SelectionCallback<Element> fn,
       SelectionScope this.scope,
       Selection source}) {
     assert(selector != null || fn != null);
     assert(source != null || scope != null);

     if (selector != null) {
       fn = (d, i, c) => c == null
           ? scope.root.querySelector(selector)
           : c.querySelector(selector);
     }

     if (source != null) {
       scope = source.scope;
       groups = new List<SelectionGroup>.generate(source.groups.length, (gi) {
         SelectionGroup g = source.groups.elementAt(gi);
         return new _SelectionGroupImpl(
             new List.generate(g.elements.length, (ei) {
               var e = g.elements.elementAt(ei);
               if (e != null) {
                 var datum = scope.datum(e);
                 var enterElement = fn(datum, ei, e);
                 if (datum != null) {
                   scope.associate(enterElement, datum);
                 }
                 return enterElement;
               } else {
                 return null;
               }
             }),
             parent: g.parent);
       });
     } 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(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<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]) {
     EventListener getEventHandler(int i, Element e) => (Event event) {
           var previous = scope.event;
           scope.event = event;
           try {
             listener(scope.datum(e), i, e);
           } finally {
             scope.event = previous;
           }
         };

     if (!type.startsWith('.')) {
       if (listener != null) {
         // Add a listener to each element.
         each((d, i, Element e) {
           var handlers = scope._listeners[e];
           if (handlers == null) scope._listeners[e] = handlers = {};
           handlers[type] = new Pair(getEventHandler(i, e), capture);
           e.addEventListener(type, handlers[type].first, capture);
         });
       } else {
         // Remove the listener from each element.
         each((d, i, Element e) {
           var handlers = scope._listeners[e];
           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<EventListener, bool> value) {
           if (s.split('.')[0] == t) {
             e.removeEventListener(s, value.first, value.last);
           }
         });
       });
     }
   }

   int get length {
     int retval = 0;
     each((d, i, e) => retval++);
     return retval;
   }

   bool get isEmpty => length == 0;

   /** First non-null element in this selection */
   Element get first {
     for (int gi = 0; gi < groups.length; gi++) {
       SelectionGroup g = groups.elementAt(gi);
       for (int ei = 0; ei < g.elements.length; ei++) {
         if (g.elements.elementAt(ei) != null) {
           return g.elements.elementAt(ei);
         }
       }
     }
     return null;
   }

   void attr(String name, val) {
     assert(name != null && name.isNotEmpty);
     attrWithCallback(name, toCallback(val));
   }

   void attrWithCallback(String name, SelectionCallback fn) {
     assert(fn != null);
     _do(
         fn,
         (e, v) =>
             v == null ? e.attributes.remove(name) : e.attributes[name] = "$v");
   }

   void classed(String name, [bool val = true]) {
     assert(name != null && name.isNotEmpty);
     classedWithCallback(name, toCallback(val));
   }

   void classedWithCallback(String name, SelectionCallback<bool> fn) {
     assert(fn != null);
     _do(fn,
         (e, v) => v == false ? e.classes.remove(name) : e.classes.add(name));
   }

   void style(String property, val, {String priority}) {
     assert(property != null && property.isNotEmpty);
     styleWithCallback(property, toCallback(val as String), priority: priority);
   }

   void styleWithCallback(String property, SelectionCallback<String> fn,
       {String priority}) {
     assert(fn != null);
     _do(
         fn,
         (Element e, String v) => v == null || v.isEmpty
             ? e.style.removeProperty(property)
             : e.style.setProperty(property, v, priority));
   }

   void text(String val) => textWithCallback(toCallback(val));

   void textWithCallback(SelectionCallback<String> fn) {
     assert(fn != null);
     _do(fn, (e, v) => e.text = v == null ? '' : v);
   }

   void html(String val) => htmlWithCallback(toCallback(val));

   void htmlWithCallback(SelectionCallback<String> fn) {
     assert(fn != null);
     _do(fn, (e, v) => e.innerHtml = v == null ? '' : v);
   }

   void remove() => _do(null, (e, _) => e.remove());

   Selection select(String selector) {
     assert(selector != null && selector.isNotEmpty);
     return new _SelectionImpl.single(selector: selector, source: this);
   }

   Selection selectWithCallback(SelectionCallback<Element> fn) {
     assert(fn != null);
     return new _SelectionImpl.single(fn: fn, source: this);
   }

   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) as Element;
         },
         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) as Element;
         },
         source: this);
   }

   Selection selectAll(String selector) {
     assert(selector != null && selector.isNotEmpty);
     return new _SelectionImpl.all(selector: selector, source: this);
   }

   Selection selectAllWithCallback(SelectionCallback<List<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 = <SelectionGroup>[],
         updateGroups = <SelectionGroup>[],
         exitGroups = <SelectionGroup>[];

     // Create a dummy node to be used with enter() selection.
     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<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));
           if (elementsByKey.containsKey(keyValue)) {
             exit[ei] = e;
           } else {
             elementsByKey[keyValue] = e;
           }
           keysOnDOM.add(keyValue);
         }

         // Iterate through the values and find values that don't have
         // corresponding elements in the DOM, collect the entering elements.
         for (int vi = 0, len = valuesLength; vi < len; ++vi) {
           final v = vals.elementAt(vi);
           var keyValue = keyFn(v);
           Element e = elementsByKey[keyValue];
           if (e != null) {
             update[vi] = e;
             scope.associate(e, v);
           } else if (!valuesByKey.containsKey(keyValue)) {
             enter[vi] = dummy(v);
           }
           valuesByKey[keyValue] = v;
           elementsByKey.remove(keyValue);
         }

         // Iterate through the previously saved keys to
         // find a list of elements that don't have data anymore.
         // We don't use elementsByKey.keys() because that does not
         // guarantee the order of returned keys.
         for (int i = 0, len = elementsLength; i < len; ++i) {
           if (elementsByKey.containsKey(keysOnDOM[i])) {
             exit[i] = g.elements.elementAt(i);
           }
         }
       } else {
         // When we don't have the key function, just use list index as the key
         int updateElementsCount = math.min(elementsLength, valuesLength);
         int i = 0;

         // Collect a list of elements getting updated in this group
         for (int len = updateElementsCount; i < len; ++i) {
           var e = g.elements.elementAt(i);
           if (e != null) {
             scope.associate(e, vals.elementAt(i));
             update[i] = e;
           } else {
             enter[i] = dummy(vals.elementAt(i));
           }
         }

         // List of elements newly getting added
         for (int len = valuesLength; i < len; ++i) {
           enter[i] = dummy(vals.elementAt(i));
         }

         // List of elements exiting this group
         for (int len = elementsLength; i < len; ++i) {
           exit[i] = g.elements.elementAt(i);
         }
       }

       // Create the element groups and set parents from the current group.
       enterGroups.add(new _SelectionGroupImpl(enter, parent: g.parent));
       updateGroups.add(new _SelectionGroupImpl(update, parent: g.parent));
       exitGroups.add(new _SelectionGroupImpl(exit, parent: g.parent));
     }

     ;

     for (int gi = 0; gi < groups.length; ++gi) {
       final g = groups.elementAt(gi);
       join(g, fn(scope.datum(g.parent), gi, g.parent));
     }

     return new _DataSelectionImpl(updateGroups, enterGroups, exitGroups, scope);
   }

   void datum(Iterable vals) {
     throw new UnimplementedError();
   }

   void datumWithCallback(SelectionCallback<Iterable> fn) {
     throw new UnimplementedError();
   }

   Transition transition() => new Transition(this);
 }

 /* Implementation of [DataSelection] */
 class _DataSelectionImpl extends _SelectionImpl implements DataSelection {
   EnterSelection enter;
   ExitSelection exit;

   _DataSelectionImpl(
       List<SelectionGroup> updated,
       List<SelectionGroup> entering,
       List<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(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),
         before: before,
         beforeFn: beforeFn);
   }

   Selection insertWithCallback(SelectionCallback<Element> fn,
       {String before, SelectionCallback<Element> beforeFn}) {
     assert(fn != null);
     return selectWithCallback((d, ei, e) {
       Element child = fn(d, ei, e);
       e.insertBefore(child, e.querySelector(before));
       return child;
     });
   }

   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 selectWithCallback((datum, ei, e) {
       Element child = fn(datum, ei, e);
       e.append(child);
       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 = <SelectionGroup>[];
     for (int gi = 0, len = groups.length; gi < len; ++gi) {
       final g = groups.elementAt(gi);
       final u = update.groups.elementAt(gi);
       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(List<SelectionGroup> groups, DataSelection update)
       : update = update,
         super.selectionGroups(groups, update.scope);
 }

 class _SelectionGroupImpl implements SelectionGroup {
   List<Element> elements;
   Element parent;
   _SelectionGroupImpl(this.elements, {this.parent});
 }
	/*
	* 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 {
	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
	* [selector] and under the group's parent element. Otherwise, [fn] is
	* called once per group with parent element's "data", "index" and the
	* "element" itself passed as parameters. [fn] must return an iterable of
	* elements to be used in each group.
	*/
	_SelectionImpl.all(
	{String selector,
	SelectionCallback<List<Element>> fn,
	SelectionScope this.scope,
	Selection source}) {
	assert(selector != null \|\| fn != null);
	assert(source != null \|\| scope != null);

	if (selector != null) {
	fn = (d, i, c) => c == null
	? scope.root.querySelectorAll(selector)
	: c.querySelectorAll(selector);
	}

	var tmpGroups = new List<SelectionGroup>();
	if (source != null) {
	scope = source.scope;
	for (int gi = 0; gi < source.groups.length; ++gi) {
	final g = source.groups.elementAt(gi);
	for (int ei = 0; ei < g.elements.length; ++ei) {
	final e = g.elements.elementAt(ei);
	if (e != null) {
	tmpGroups.add(
	new _SelectionGroupImpl(fn(scope.datum(e), gi, e), parent: e));
	}
	}
	}
	} else {
	tmpGroups
	.add(new _SelectionGroupImpl(fn(null, 0, null), parent: scope.root));
	}
	groups = tmpGroups;
	}

	/**
	* Same as [all] but only uses the first element matching [selector] when
	* [selector] is specified. Otherwise, call [fn] which must return the
	* element to be selected.
	*/
	_SelectionImpl.single(
	{String selector,
	SelectionCallback<Element> fn,
	SelectionScope this.scope,
	Selection source}) {
	assert(selector != null \|\| fn != null);
	assert(source != null \|\| scope != null);

	if (selector != null) {
	fn = (d, i, c) => c == null
	? scope.root.querySelector(selector)
	: c.querySelector(selector);
	}

	if (source != null) {
	scope = source.scope;
	groups = new List<SelectionGroup>.generate(source.groups.length, (gi) {
	SelectionGroup g = source.groups.elementAt(gi);
	return new _SelectionGroupImpl(
	new List.generate(g.elements.length, (ei) {
	var e = g.elements.elementAt(ei);
	if (e != null) {
	var datum = scope.datum(e);
	var enterElement = fn(datum, ei, e);
	if (datum != null) {
	scope.associate(enterElement, datum);
	}
	return enterElement;
	} else {
	return null;
	}
	}),
	parent: g.parent);
	});
	} 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(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<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]) {
	EventListener getEventHandler(int i, Element e) => (Event event) {
	var previous = scope.event;
	scope.event = event;
	try {
	listener(scope.datum(e), i, e);
	} finally {
	scope.event = previous;
	}
	};

	if (!type.startsWith('.')) {
	if (listener != null) {
	// Add a listener to each element.
	each((d, i, Element e) {
	var handlers = scope._listeners[e];
	if (handlers == null) scope._listeners[e] = handlers = {};
	handlers[type] = new Pair(getEventHandler(i, e), capture);
	e.addEventListener(type, handlers[type].first, capture);
	});
	} else {
	// Remove the listener from each element.
	each((d, i, Element e) {
	var handlers = scope._listeners[e];
	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<EventListener, bool> value) {
	if (s.split('.')[0] == t) {
	e.removeEventListener(s, value.first, value.last);
	}
	});
	});
	}
	}

	int get length {
	int retval = 0;
	each((d, i, e) => retval++);
	return retval;
	}

	bool get isEmpty => length == 0;

	/** First non-null element in this selection */
	Element get first {
	for (int gi = 0; gi < groups.length; gi++) {
	SelectionGroup g = groups.elementAt(gi);
	for (int ei = 0; ei < g.elements.length; ei++) {
	if (g.elements.elementAt(ei) != null) {
	return g.elements.elementAt(ei);
	}
	}
	}
	return null;
	}

	void attr(String name, val) {
	assert(name != null && name.isNotEmpty);
	attrWithCallback(name, toCallback(val));
	}

	void attrWithCallback(String name, SelectionCallback fn) {
	assert(fn != null);
	_do(
	fn,
	(e, v) =>
	v == null ? e.attributes.remove(name) : e.attributes[name] = "$v");
	}

	void classed(String name, [bool val = true]) {
	assert(name != null && name.isNotEmpty);
	classedWithCallback(name, toCallback(val));
	}

	void classedWithCallback(String name, SelectionCallback<bool> fn) {
	assert(fn != null);
	_do(fn,
	(e, v) => v == false ? e.classes.remove(name) : e.classes.add(name));
	}

	void style(String property, val, {String priority}) {
	assert(property != null && property.isNotEmpty);
	styleWithCallback(property, toCallback(val as String), priority: priority);
	}

	void styleWithCallback(String property, SelectionCallback<String> fn,
	{String priority}) {
	assert(fn != null);
	_do(
	fn,
	(Element e, String v) => v == null \|\| v.isEmpty
	? e.style.removeProperty(property)
	: e.style.setProperty(property, v, priority));
	}

	void text(String val) => textWithCallback(toCallback(val));

	void textWithCallback(SelectionCallback<String> fn) {
	assert(fn != null);
	_do(fn, (e, v) => e.text = v == null ? '' : v);
	}

	void html(String val) => htmlWithCallback(toCallback(val));

	void htmlWithCallback(SelectionCallback<String> fn) {
	assert(fn != null);
	_do(fn, (e, v) => e.innerHtml = v == null ? '' : v);
	}

	void remove() => _do(null, (e, _) => e.remove());

	Selection select(String selector) {
	assert(selector != null && selector.isNotEmpty);
	return new _SelectionImpl.single(selector: selector, source: this);
	}

	Selection selectWithCallback(SelectionCallback<Element> fn) {
	assert(fn != null);
	return new _SelectionImpl.single(fn: fn, source: this);
	}

	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) as Element;
	},
	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) as Element;
	},
	source: this);
	}

	Selection selectAll(String selector) {
	assert(selector != null && selector.isNotEmpty);
	return new _SelectionImpl.all(selector: selector, source: this);
	}

	Selection selectAllWithCallback(SelectionCallback<List<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 = <SelectionGroup>[],
	updateGroups = <SelectionGroup>[],
	exitGroups = <SelectionGroup>[];

	// Create a dummy node to be used with enter() selection.
	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<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));
	if (elementsByKey.containsKey(keyValue)) {
	exit[ei] = e;
	} else {
	elementsByKey[keyValue] = e;
	}
	keysOnDOM.add(keyValue);
	}

	// Iterate through the values and find values that don't have
	// corresponding elements in the DOM, collect the entering elements.
	for (int vi = 0, len = valuesLength; vi < len; ++vi) {
	final v = vals.elementAt(vi);
	var keyValue = keyFn(v);
	Element e = elementsByKey[keyValue];
	if (e != null) {
	update[vi] = e;
	scope.associate(e, v);
	} else if (!valuesByKey.containsKey(keyValue)) {
	enter[vi] = dummy(v);
	}
	valuesByKey[keyValue] = v;
	elementsByKey.remove(keyValue);
	}

	// Iterate through the previously saved keys to
	// find a list of elements that don't have data anymore.
	// We don't use elementsByKey.keys() because that does not
	// guarantee the order of returned keys.
	for (int i = 0, len = elementsLength; i < len; ++i) {
	if (elementsByKey.containsKey(keysOnDOM[i])) {
	exit[i] = g.elements.elementAt(i);
	}
	}
	} else {
	// When we don't have the key function, just use list index as the key
	int updateElementsCount = math.min(elementsLength, valuesLength);
	int i = 0;

	// Collect a list of elements getting updated in this group
	for (int len = updateElementsCount; i < len; ++i) {
	var e = g.elements.elementAt(i);
	if (e != null) {
	scope.associate(e, vals.elementAt(i));
	update[i] = e;
	} else {
	enter[i] = dummy(vals.elementAt(i));
	}
	}

	// List of elements newly getting added
	for (int len = valuesLength; i < len; ++i) {
	enter[i] = dummy(vals.elementAt(i));
	}

	// List of elements exiting this group
	for (int len = elementsLength; i < len; ++i) {
	exit[i] = g.elements.elementAt(i);
	}
	}

	// Create the element groups and set parents from the current group.
	enterGroups.add(new _SelectionGroupImpl(enter, parent: g.parent));
	updateGroups.add(new _SelectionGroupImpl(update, parent: g.parent));
	exitGroups.add(new _SelectionGroupImpl(exit, parent: g.parent));
	}

	;

	for (int gi = 0; gi < groups.length; ++gi) {
	final g = groups.elementAt(gi);
	join(g, fn(scope.datum(g.parent), gi, g.parent));
	}

	return new _DataSelectionImpl(updateGroups, enterGroups, exitGroups, scope);
	}

	void datum(Iterable vals) {
	throw new UnimplementedError();
	}

	void datumWithCallback(SelectionCallback<Iterable> fn) {
	throw new UnimplementedError();
	}

	Transition transition() => new Transition(this);
	}

	/* Implementation of [DataSelection] */
	class _DataSelectionImpl extends _SelectionImpl implements DataSelection {
	EnterSelection enter;
	ExitSelection exit;

	_DataSelectionImpl(
	List<SelectionGroup> updated,
	List<SelectionGroup> entering,
	List<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(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),
	before: before,
	beforeFn: beforeFn);
	}

	Selection insertWithCallback(SelectionCallback<Element> fn,
	{String before, SelectionCallback<Element> beforeFn}) {
	assert(fn != null);
	return selectWithCallback((d, ei, e) {
	Element child = fn(d, ei, e);
	e.insertBefore(child, e.querySelector(before));
	return child;
	});
	}

	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 selectWithCallback((datum, ei, e) {
	Element child = fn(datum, ei, e);
	e.append(child);
	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 = <SelectionGroup>[];
	for (int gi = 0, len = groups.length; gi < len; ++gi) {
	final g = groups.elementAt(gi);
	final u = update.groups.elementAt(gi);
	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(List<SelectionGroup> groups, DataSelection update)
	: update = update,
	super.selectionGroups(groups, update.scope);
	}

	class _SelectionGroupImpl implements SelectionGroup {
	List<Element> elements;
	Element parent;
	_SelectionGroupImpl(this.elements, {this.parent});
	}