Upgrade to 1.0 and switch clients to dom-repeat where needed.

third_party/polymer/v0_8/components-chromium/paper-input/paper-input-container-extracted.js

 
 (function() {
 
   Polymer({
 
     is: 'paper-input-container',
 
-    enableCustomStyleProperties: true,
-
     properties: {
 
       /**
-       * Set to true to disable the floating label.
+       * Set to true to disable the floating label. The label disappears when the input value is
+       * not null.
        */
       noLabelFloat: {
         type: Boolean,
         value: false
       },
 
       /**
+       * Set to true to always float the floating label.
+       */
+      alwaysFloatLabel: {
+        type: Boolean,
+        value: false
+      },
+
+      /**
        * The attribute to listen for value changes on.
        */
       attrForValue: {
         type: String,
         value: 'bind-value'
       },
 
       /**
-       * Set to true to auto-validate the input value.
+       * Set to true to auto-validate the input value when it changes.
        */
       autoValidate: {
         type: Boolean,
         value: false
       },
 
       /**
+       * True if the input is invalid. This property is set automatically when the input value
+       * changes if auto-validating, or when the `iron-input-valid` event is heard from a child.
+       */
+      invalid: {
+        observer: '_invalidChanged',
+        type: Boolean,
+        value: false
+      },
+
+      /**
        * True if the input has focus.
        */
       focused: {
         readOnly: true,
         type: Boolean,
         value: false
       },
 
       _addons: {
         type: Array,
         value: function() {
           return [];
         }
       },
 
       _inputHasContent: {
         type: Boolean,
         value: false
       },
 
-      _inputIsInvalid: {
-        type: Boolean,
-        value: false
-      },
-
       _inputSelector: {
         type: String,
         value: 'input,textarea,.paper-input-input'
       },
 
       _boundOnFocus: {
         type: Function,
         value: function() {
           return this._onFocus.bind(this);
         }
       },
 
       _boundOnBlur: {
         type: Function,
         value: function() {
           return this._onBlur.bind(this);
         }
       },
 
+      _boundOnInput: {
+        type: Function,
+        value: function() {
+          this._onInput.bind(this)
+        }
+      },
+
       _boundValueChanged: {
         type: Function,
         value: function() {
           return this._onValueChanged.bind(this);
         }
       }
 
     },
 
     listeners: {
       'addon-attached': '_onAddonAttached',
-      'input': '_onInput'
+      'iron-input-validate': '_onIronInputValidate'
     },
 
     get _valueChangedEvent() {
       return this.attrForValue + '-changed';
     },
 
     get _propertyForValue() {
       return Polymer.CaseMap.dashToCamelCase(this.attrForValue);
     },
 
     get _inputElement() {
       return Polymer.dom(this).querySelector(this._inputSelector);
     },
 
     ready: function() {
       this.addEventListener('focus', this._boundOnFocus, true);
       this.addEventListener('blur', this._boundOnBlur, true);
-      this.addEventListener(this._valueChangedEvent, this._boundValueChanged, true);
+      if (this.attrForValue) {
+        this._inputElement.addEventListener(this._valueChangedEvent, this._boundValueChanged);
+      } else {
+        this.addEventListener('input', this._onInput);
+      }
     },
 
     attached: function() {
-      this._handleInput(this._inputElement);
+      this._handleValue(this._inputElement);
     },
 
     _onAddonAttached: function(event) {
       this._addons.push(event.target);
-      this._handleInput(this._inputElement);
+      this._handleValue(this._inputElement);
     },
 
     _onFocus: function() {
       this._setFocused(true);
     },
 
     _onBlur: function() {
       this._setFocused(false);
     },
 
     _onInput: function(event) {
-      this._handleInput(event.target);
+      this._handleValue(event.target);
     },
 
     _onValueChanged: function(event) {
-      this._handleInput(event.target);
+      this._handleValue(event.target);
     },
 
-    _handleInput: function(inputElement) {
+    _handleValue: function(inputElement) {
       var value = inputElement[this._propertyForValue] || inputElement.value;
-      var valid = inputElement.checkValidity();
+
+      if (this.autoValidate) {
+        var valid;
+        if (inputElement.validate) {
+          valid = inputElement.validate(value);
+        } else {
+          valid = inputElement.checkValidity();
+        }
+        this.invalid = !valid;
+      }
 
       // type="number" hack needed because this.value is empty until it's valid
-      if (value || inputElement.type === 'number' && !valid) {
+      if (value || (inputElement.type === 'number' && !inputElement.checkValidity())) {
         this._inputHasContent = true;
       } else {
         this._inputHasContent = false;
       }
 
-      if (this.autoValidate) {
-        this._inputIsInvalid = !valid;
-      }
+      this.updateAddons({
+        inputElement: inputElement,
+        value: value,
+        invalid: this.invalid
+      });
+    },
 
-      // notify add-ons
-      for (var addon, i = 0; addon = this._addons[i]; i++) {
-        // need to set all of these, or call method... thanks input type="number"!
-        addon.inputElement = inputElement;
-        addon.value = value;
-        addon.invalid = !valid;
+    _onIronInputValidate: function(event) {
+      this.invalid = this._inputElement.invalid;
+    },
+
+    _invalidChanged: function() {
+      if (this._addons) {
+        this.updateAddons({invalid: this.invalid});
       }
     },
 
-    _computeInputContentClass: function(noLabelFloat, focused, _inputHasContent, _inputIsInvalid) {
+    /**
+     * Call this to update the state of add-ons.
+     * @param {Object} state Add-on state.
+     */
+    updateAddons: function(state) {
+      for (var addon, index = 0; addon = this._addons[index]; index++) {
+        addon.update(state);
+      }
+    },
+
+    _computeInputContentClass: function(noLabelFloat, alwaysFloatLabel, focused, invalid, _inputHasContent) {
       var cls = 'input-content';
       if (!noLabelFloat) {
-        if (_inputHasContent) {
+        if (alwaysFloatLabel || _inputHasContent) {
           cls += ' label-is-floating';
-          if (_inputIsInvalid) {
+          if (invalid) {
             cls += ' is-invalid';
           } else if (focused) {
             cls += " label-is-highlighted";
           }
         }
       } else {
         if (_inputHasContent) {
           cls += ' label-is-hidden';
         }
       }
       return cls;
     },
 
-    _computeUnderlineClass: function(focused, _inputIsInvalid) {
+    _computeUnderlineClass: function(focused, invalid) {
       var cls = 'underline';
-      if (_inputIsInvalid) {
+      if (invalid) {
         cls += ' is-invalid';
       } else if (focused) {
         cls += ' is-highlighted'
       }
       return cls;
     },
 
-    _computeAddOnContentClass: function(focused, _inputIsInvalid) {
+    _computeAddOnContentClass: function(focused, invalid) {
       var cls = 'add-on-content';
-      if (_inputIsInvalid) {
+      if (invalid) {
         cls += ' is-invalid';
       } else if (focused) {
         cls += ' is-highlighted'
       }
       return cls;
     }
 
   });
 
 })();