Update Polymer from 1.1.4 -> 1.1.5

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

-
-
-  Polymer({
+Polymer({
     is: 'paper-slider',
 
     behaviors: [
       Polymer.IronFormElementBehavior,
       Polymer.PaperInkyFocusBehavior,
       Polymer.IronRangeBehavior
     ],
 
     properties: {
 
@@ skipping 83 matching lines @@
 
       markers: {
         type: Array,
         readOnly: true,
         value: []
       },
     },
 
     observers: [
       '_updateKnob(value, min, max, snaps, step)',
-      '_minChanged(min)',
-      '_maxChanged(max)',
       '_valueChanged(value)',
       '_immediateValueChanged(immediateValue)'
     ],
 
     hostAttributes: {
       role: 'slider',
       tabindex: 0
     },
 
     keyBindings: {
       'left down pagedown home': '_decrementKey',
       'right up pageup end': '_incrementKey'
     },
 
     ready: function() {
       // issue polymer/polymer#1305
-
       this.async(function() {
         this._updateKnob(this.value);
       }, 1);
     },
 
     /**
      * Increases value by `step` but not above `max`.
      * @method increment
      */
     increment: function() {
       this.value = this._clampValue(this.value + this.step);
     },
 
     /**
      * Decreases value by `step` but not below `min`.
      * @method decrement
      */
     decrement: function() {
       this.value = this._clampValue(this.value - this.step);
     },
 
-    _updateKnob: function(value) {
+    _updateKnob: function(value, min, max, snaps, step) {
+      this.setAttribute('aria-valuemin', min);
+      this.setAttribute('aria-valuemax', max);
+      this.setAttribute('aria-valuenow', value);
+
       this._positionKnob(this._calcRatio(value));
     },
 
-    _minChanged: function() {
-      this.setAttribute('aria-valuemin', this.min);
-    },
-
-    _maxChanged: function() {
-      this.setAttribute('aria-valuemax', this.max);
-    },
-
     _valueChanged: function() {
-      this.setAttribute('aria-valuenow', this.value);
       this.fire('value-change');
     },
 
     _immediateValueChanged: function() {
       if (this.dragging) {
         this.fire('immediate-value-change');
       } else {
         this.value = this.immediateValue;
       }
     },
 
     _secondaryProgressChanged: function() {
       this.secondaryProgress = this._clampValue(this.secondaryProgress);
     },
 
-    _fixForInput: function(immediateValue) {
-      // paper-input/issues/114
-      return this.immediateValue.toString();
-    },
-
     _expandKnob: function() {
       this._setExpand(true);
     },
 
     _resetKnob: function() {
       this.cancelDebouncer('expandKnob');
       this._setExpand(false);
     },
 
     _positionKnob: function(ratio) {
       this._setImmediateValue(this._calcStep(this._calcKnobPosition(ratio)));
       this._setRatio(this._calcRatio(this.immediateValue));
 
       this.$.sliderKnob.style.left = (this.ratio * 100) + '%';
     },
 
-    _inputChange: function() {
-      this.value = this.$$('#input').value;
-      this.fire('change');
-    },
-
     _calcKnobPosition: function(ratio) {
       return (this.max - this.min) * ratio + this.min;
     },
 
     _onTrack: function(event) {
       event.stopPropagation();
       switch (event.detail.state) {
         case 'start':
           this._trackStart(event);
           break;
         case 'track':
           this._trackX(event);
           break;
         case 'end':
           this._trackEnd();
           break;
       }
     },
 
     _trackStart: function(event) {
       this._w = this.$.sliderBar.offsetWidth;
       this._x = this.ratio * this._w;
       this._startx = this._x || 0;
       this._minx = - this._startx;
       this._maxx = this._w - this._startx;
       this.$.sliderKnob.classList.add('dragging');
-
       this._setDragging(true);
     },
 
     _trackX: function(e) {
       if (!this.dragging) {
         this._trackStart(e);
       }
 
       var dx = Math.min(this._maxx, Math.max(this._minx, e.detail.dx));
       this._x = this._startx + dx;
@@ skipping 86 matching lines @@
         snaps: this.snaps,
         ring: this.immediateValue <= this.min,
         expand: this.expand,
         dragging: this.dragging,
         transiting: this.transiting,
         editable: this.editable
       });
     },
 
     _incrementKey: function(event) {
-      if (event.detail.key === 'end') {
-        this.value = this.max;
-      } else {
-        this.increment();
+      if (!this.disabled) {
+        if (event.detail.key === 'end') {
+          this.value = this.max;
+        } else {
+          this.increment();
+        }
+        this.fire('change');
       }
+    },
+
+    _decrementKey: function(event) {
+      if (!this.disabled) {
+        if (event.detail.key === 'home') {
+          this.value = this.min;
+        } else {
+          this.decrement();
+        }
+        this.fire('change');
+      }
+    },
+
+    _changeValue: function(event) {
+      this.value = event.target.value;
       this.fire('change');
     },
 
-    _decrementKey: function(event) {
-      if (event.detail.key === 'home') {
-        this.value = this.min;
-      } else {
-        this.decrement();
+    _inputKeyDown: function(event) {
+      event.stopPropagation();
+    },
+
+    // create the element ripple inside the `sliderKnob`
+    _createRipple: function() {
+      this._rippleContainer = this.$.sliderKnob;
+      return Polymer.PaperInkyFocusBehaviorImpl._createRipple.call(this);
+    },
+
+    // Hide the ripple when user is not interacting with keyboard.
+    // This behavior is different from other ripple-y controls, but is
+    // according to spec: https://www.google.com/design/spec/components/sliders.html
+    _focusedChanged: function(receivedFocusFromKeyboard) {
+      if (receivedFocusFromKeyboard) {
+        this.ensureRipple();
       }
-      this.fire('change');
+      if (this.hasRipple()) {
+        // note, ripple must be un-hidden prior to setting `holdDown`
+        if (receivedFocusFromKeyboard) {
+          this._ripple.removeAttribute('hidden');
+        } else {
+          this._ripple.setAttribute('hidden', '');
+        }
+        this._ripple.holdDown = receivedFocusFromKeyboard;
+      }
     }
+
   });
 
   /**
    * Fired when the slider's value changes.
    *
    * @event value-change
    */
 
   /**
    * Fired when the slider's immediateValue changes.
    *
    * @event immediate-value-change
    */
 
   /**
    * Fired when the slider's value changes due to user interaction.
    *
    * Changes to the slider's value due to changes in an underlying
    * bound variable will not trigger this event.
    *
    * @event change
-   */
-
+   */