update to polymer js 0.5.1

pkg/template_binding/lib/js/observe.js

 /*
  * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
  * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
  * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
  * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
  * Code distributed by Google as part of the polymer project is also
  * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
  */
 
 (function(global) {
@@ skipping 372 matching lines @@
       }
       return obj;
     },
 
     iterateObjects: function(obj, observe) {
       for (var i = 0; i < this.length; i++) {
         if (i)
           obj = obj[this[i - 1]];
         if (!isObject(obj))
           return;
-        observe(obj, this[0]);
+        observe(obj, this[i]);
       }
     },
 
     compiledGetValueFromFn: function() {
       var str = '';
       var pathString = 'obj';
       str += 'if (obj != null';
       var i = 0;
       var key;
       for (; i < (this.length - 1); i++) {
@@ skipping 100 matching lines @@
       return false;
 
     for (var i = 0; i < eomTasks.length; i++) {
       eomTasks[i]();
     }
     eomTasks.length = 0;
     return true;
   }
 
   var runEOM = hasObserve ? (function(){
-    var eomObj = { pingPong: true };
-    var eomRunScheduled = false;
-
-    Object.observe(eomObj, function() {
-      runEOMTasks();
-      eomRunScheduled = false;
-    });
-
     return function(fn) {
-      eomTasks.push(fn);
-      if (!eomRunScheduled) {
-        eomRunScheduled = true;
-        eomObj.pingPong = !eomObj.pingPong;
-      }
-    };
+      return Promise.resolve().then(fn);
+    }
   })() :
   (function() {
     return function(fn) {
       eomTasks.push(fn);
     };
   })();
 
   var observedObjectCache = [];
 
   function newObservedObject() {
@@ skipping 117 matching lines @@
 
       for (var i = 0; i < observers.length; i++) {
         observer = observers[i];
         if (observer.state_ == OPENED) {
           observer.check_();
         }
       }
     }
 
     var record = {
-      object: undefined,
       objects: objects,
+      get rootObject() { return rootObj; },
+      set rootObject(value) {
+        rootObj = value;
+        rootObjProps = {};
+      },
       open: function(obs, object) {
-        if (!rootObj) {
-          rootObj = object;
-          rootObjProps = {};
-        }
-
         observers.push(obs);
         observerCount++;
         obs.iterateObjects_(observe);
       },
       close: function(obs) {
         observerCount--;
         if (observerCount > 0) {
           return;
         }
 
         for (var i = 0; i < objects.length; i++) {
           Object.unobserve(objects[i], callback);
           Observer.unobservedCount++;
         }
 
         observers.length = 0;
         objects.length = 0;
         rootObj = undefined;
         rootObjProps = undefined;
         observedSetCache.push(this);
-      }
+        if (lastObservedSet === this)
+          lastObservedSet = null;
+      },
     };
 
     return record;
   }
 
   var lastObservedSet;
 
   function getObservedSet(observer, obj) {
-    if (!lastObservedSet || lastObservedSet.object !== obj) {
+    if (!lastObservedSet || lastObservedSet.rootObject !== obj) {
       lastObservedSet = observedSetCache.pop() || newObservedSet();
-      lastObservedSet.object = obj;
+      lastObservedSet.rootObject = obj;
     }
     lastObservedSet.open(observer, obj);
     return lastObservedSet;
   }
 
   var UNOPENED = 0;
   var OPENED = 1;
   var CLOSED = 2;
   var RESETTING = 3;
 
@@ skipping 967 matching lines @@
         return
       };
 
       splices = splices.concat(calcSplices(array, splice.index, splice.index + splice.addedCount,
                                            splice.removed, 0, splice.removed.length));
     });
 
     return splices;
   }
 
-  global.Observer = Observer;
-  global.Observer.runEOM_ = runEOM;
-  global.Observer.observerSentinel_ = observerSentinel; // for testing.
-  global.Observer.hasObjectObserve = hasObserve;
-  global.ArrayObserver = ArrayObserver;
-  global.ArrayObserver.calculateSplices = function(current, previous) {
+  // Export the observe-js object for **Node.js**, with
+  // backwards-compatibility for the old `require()` API. If we're in
+  // the browser, export as a global object.
+
+  var expose = global;
+
+  if (typeof exports !== 'undefined') {
+    if (typeof module !== 'undefined' && module.exports) {
+      expose = exports = module.exports;
+    }
+    expose = exports;
+  } 
+
+  expose.Observer = Observer;
+  expose.Observer.runEOM_ = runEOM;
+  expose.Observer.observerSentinel_ = observerSentinel; // for testing.
+  expose.Observer.hasObjectObserve = hasObserve;
+  expose.ArrayObserver = ArrayObserver;
+  expose.ArrayObserver.calculateSplices = function(current, previous) {
     return arraySplice.calculateSplices(current, previous);
   };
 
-  global.ArraySplice = ArraySplice;
-  global.ObjectObserver = ObjectObserver;
-  global.PathObserver = PathObserver;
-  global.CompoundObserver = CompoundObserver;
-  global.Path = Path;
-  global.ObserverTransform = ObserverTransform;
+  expose.ArraySplice = ArraySplice;
+  expose.ObjectObserver = ObjectObserver;
+  expose.PathObserver = PathObserver;
+  expose.CompoundObserver = CompoundObserver;
+  expose.Path = Path;
+  expose.ObserverTransform = ObserverTransform;
+  
 })(typeof global !== 'undefined' && global && typeof module !== 'undefined' && module ? global : this || window);