Update Polymer from 1.1.4 -> 1.1.5

third_party/polymer/v1_0/components-chromium/paper-ripple/paper-ripple-extracted.js

-
-  (function() {
+(function() {
     var Utility = {
       distance: function(x1, y1, x2, y2) {
         var xDelta = (x1 - x2);
         var yDelta = (y1 - y2);
 
         return Math.sqrt(xDelta * xDelta + yDelta * yDelta);
       },
 
       now: window.performance && window.performance.now ?
           window.performance.now.bind(window.performance) : Date.now
@@ skipping 357 matching lines @@
         /**
          * If true, the ripple will remain in the "down" state until `holdDown`
          * is set to false again.
          */
         holdDown: {
           type: Boolean,
           value: false,
           observer: '_holdDownChanged'
         },
 
+        /**
+         * If true, the ripple will not generate a ripple effect 
+         * via pointer interaction.
+         * Calling ripple's imperative api like `simulatedRipple` will 
+         * still generate the ripple effect.
+         */
+        noink: {
+          type: Boolean,
+          value: false
+        },
+
         _animating: {
           type: Boolean
         },
 
         _boundAnimate: {
           type: Function,
           value: function() {
             return this.animate.bind(this);
           }
         }
       },
 
+      observers: [
+        '_noinkChanged(noink, isAttached)'
+      ],
+
       get target () {
         var ownerRoot = Polymer.dom(this).getOwnerRoot();
         var target;
 
         if (this.parentNode.nodeType == 11) { // DOCUMENT_FRAGMENT_NODE
           target = ownerRoot.host;
         } else {
           target = this.parentNode;
         }
 
         return target;
       },
 
       keyBindings: {
         'enter:keydown': '_onEnterKeydown',
         'space:keydown': '_onSpaceKeydown',
         'space:keyup': '_onSpaceKeyup'
       },
 
       attached: function() {
-        this.listen(this.target, 'up', 'upAction');
-        this.listen(this.target, 'down', 'downAction');
+        this.listen(this.target, 'up', 'uiUpAction');
+        this.listen(this.target, 'down', 'uiDownAction');
+      },
 
-        if (!this.target.hasAttribute('noink')) {
-          this.keyEventTarget = this.target;
-        }
+      detached: function() {
+        this.unlisten(this.target, 'up', 'uiUpAction');
+        this.unlisten(this.target, 'down', 'uiDownAction');
       },
 
       get shouldKeepAnimating () {
         for (var index = 0; index < this.ripples.length; ++index) {
           if (!this.ripples[index].isAnimationComplete) {
             return true;
           }
         }
 
         return false;
       },
 
       simulatedRipple: function() {
         this.downAction(null);
 
         // Please see polymer/polymer#1305
         this.async(function() {
           this.upAction();
         }, 1);
       },
 
-      /** @param {Event=} event */
+      /** 
+       * Provokes a ripple down effect via a UI event, 
+       * respecting the `noink` property.
+       * @param {Event=} event 
+       */
+      uiDownAction: function(event) {
+        if (!this.noink) {
+          this.downAction(event);
+        }
+      },
+
+      /** 
+       * Provokes a ripple down effect via a UI event, 
+       * *not* respecting the `noink` property.
+       * @param {Event=} event 
+       */
       downAction: function(event) {
         if (this.holdDown && this.ripples.length > 0) {
           return;
         }
 
         var ripple = this.addRipple();
 
         ripple.downAction(event);
 
         if (!this._animating) {
           this.animate();
         }
       },
 
-      /** @param {Event=} event */
+      /** 
+       * Provokes a ripple up effect via a UI event, 
+       * respecting the `noink` property.
+       * @param {Event=} event 
+       */
+      uiUpAction: function(event) {
+        if (!this.noink) {
+          this.upAction(event);
+        }
+      },
+
+      /** 
+       * Provokes a ripple up effect via a UI event, 
+       * *not* respecting the `noink` property.
+       * @param {Event=} event 
+       */
       upAction: function(event) {
         if (this.holdDown) {
           return;
         }
 
         this.ripples.forEach(function(ripple) {
           ripple.upAction(event);
         });
 
         this.animate();
@@ skipping 52 matching lines @@
         }
 
         if (!this.shouldKeepAnimating && this.ripples.length === 0) {
           this.onAnimationComplete();
         } else {
           window.requestAnimationFrame(this._boundAnimate);
         }
       },
 
       _onEnterKeydown: function() {
-        this.downAction();
-        this.async(this.upAction, 1);
+        this.uiDownAction();
+        this.async(this.uiUpAction, 1);
       },
 
       _onSpaceKeydown: function() {
-        this.downAction();
+        this.uiDownAction();
       },
 
       _onSpaceKeyup: function() {
-        this.upAction();
+        this.uiUpAction();
       },
 
-      _holdDownChanged: function(holdDown) {
-        if (holdDown) {
+      // note: holdDown does not respect noink since it can be a focus based
+      // effect.
+      _holdDownChanged: function(newVal, oldVal) {
+        if (oldVal === undefined) {
+          return;
+        }
+        if (newVal) {
           this.downAction();
         } else {
           this.upAction();
         }
+      },
+
+      _noinkChanged: function(noink, attached) {
+        if (attached) {
+          this.keyEventTarget = noink ? this : this.target;
+        }
       }
     });
-  })();
+  })();