Fix widget.dart to work with the latest web_ui library. Specifically, query selectors need to use "…

lib/src/effects/show_hide.dart

 part of effects;
 
 class ShowHideAction extends _Enum {
   static const ShowHideAction SHOW = const ShowHideAction._internal("show");
   static const ShowHideAction HIDE = const ShowHideAction._internal('hide');
   static const ShowHideAction TOGGLE = const ShowHideAction._internal('toggle');
 
   const ShowHideAction._internal(String name) : super(name);
 }
 
@@ skipping 135 matching lines @@
     assert(element != null);
     assert(desiredDuration != null);
     assert(effect != null);
     assert(effectTiming != null);
     final values = _values[element];
 
     switch(values.currentState) {
       case ShowHideState.SHOWING:
         // no op - let the current animation finish
         assert(_AnimatingValues.isAnimating(element));
-        return new Future.immediate(ShowHideResult.NOOP);
+        return new Future.value(ShowHideResult.NOOP);
       case ShowHideState.SHOWN:
         // no op. If shown leave it.
         assert(!_AnimatingValues.isAnimating(element));
-        return new Future.immediate(ShowHideResult.NOOP);
+        return new Future.value(ShowHideResult.NOOP);
       case ShowHideState.HIDING:
         _AnimatingValues.cancelAnimation(element);
         break;
       case ShowHideState.HIDDEN:
         // handeled below with a fall-through
         break;
       default:
         throw new DetailedArgumentError('oldState', 'the provided value ${values.currentState} is not supported');
     }
 
     assert(!_AnimatingValues.isAnimating(element));
     _finishShow(element);
     final durationMS = effect.startShow(element, desiredDuration, effectTiming);
     if(durationMS > 0) {
 
       // _finishShow sets the currentState to shown, but we know better since we're animating
       assert(values.currentState == ShowHideState.SHOWN);
       values.currentState = ShowHideState.SHOWING;
       return _AnimatingValues.scheduleCleanup(durationMS, element, effect.clearAnimation, _finishShow);
     } else {
       assert(values.currentState == ShowHideState.SHOWN);
-      return new Future.immediate(ShowHideResult.IMMEDIATE);
+      return new Future.value(ShowHideResult.IMMEDIATE);
     }
   }
 
   static void _finishShow(Element element) {
     final values = _values[element];
     assert(!_AnimatingValues.isAnimating(element));
     element.style.display = _getShowDisplayValue(element);
     values.currentState = ShowHideState.SHOWN;
   }
 
   static Future<ShowHideResult> _requestHide(Element element, int desiredDuration,
       ShowHideEffect effect, EffectTiming effectTiming) {
     assert(element != null);
     assert(desiredDuration != null);
     assert(effect != null);
     assert(effectTiming != null);
     final values = _values[element];
 
     switch(values.currentState) {
       case ShowHideState.HIDING:
         // no op - let the current animation finish
         assert(_AnimatingValues.isAnimating(element));
-        return new Future.immediate(ShowHideResult.NOOP);
+        return new Future.value(ShowHideResult.NOOP);
       case ShowHideState.HIDDEN:
         // it's possible we're here because the inferred calculated value is 'none'
         // this hard-wires the local display value to 'none'...just to be clear
         _finishHide(element);
-        return new Future.immediate(ShowHideResult.NOOP);
+        return new Future.value(ShowHideResult.NOOP);
       case ShowHideState.SHOWING:
         _AnimatingValues.cancelAnimation(element);
         break;
       case ShowHideState.SHOWN:
         // handeled below with a fall-through
         break;
       default:
         throw new DetailedArgumentError('oldState', 'the provided value ${values.currentState} is not supported');
     }
 
     assert(!_AnimatingValues.isAnimating(element));
     final durationMS = effect.startHide(element, desiredDuration, effectTiming);
     if(durationMS > 0) {
       _values[element].currentState = ShowHideState.HIDING;
       return _AnimatingValues.scheduleCleanup(durationMS, element, effect.clearAnimation, _finishHide);
     } else {
       _finishHide(element);
       assert(values.currentState == ShowHideState.HIDDEN);
-      return new Future.immediate(ShowHideResult.IMMEDIATE);
+      return new Future.value(ShowHideResult.IMMEDIATE);
     }
   }
 
   static void _finishHide(Element element) {
     final values = _values[element];
     assert(!_AnimatingValues.isAnimating(element));
     element.style.display = 'none';
     values.currentState = ShowHideState.HIDDEN;
   }
 
@@ skipping 82 matching lines @@
   }
 
   static Future<ShowHideResult> scheduleCleanup(int durationMS, Element element,
                               Action1<Element> cleanupAction,
                               Action1<Element> finishAction) {
 
     final value = new _AnimatingValues._internal(element, cleanupAction, finishAction);
     return value._start(durationMS);
   }
 }