npm_modules: Fork bower_components into Polymer 0.4.0 and 0.5.0 versions

polymer_0.5.0/bower_components/core-ajax/core-ajax.html

 <!--
 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
 -->
 
 <!--
 @group Polymer Core Elements
 
 The `core-ajax` element exposes `XMLHttpRequest` functionality.
 
     <core-ajax
         auto
         url="http://gdata.youtube.com/feeds/api/videos/"
         params='{"alt":"json", "q":"chrome"}'
         handleAs="json"
         on-core-response="{{handleResponse}}"></core-ajax>
 
 With `auto` set to `true`, the element performs a request whenever
-its `url` or `params` properties are changed.
+its `url`, `params` or `body` properties are changed.
 
 Note: The `params` attribute must be double quoted JSON.
 
 You can trigger a request explicitly by calling `go` on the
 element.
 
 @element core-ajax
 @status beta
 @homepage github.io
 -->
 <link rel="import" href="core-xhr.html">
-<polymer-element name="core-ajax" hidden attributes="url handleAs auto params response error method headers body contentType withCredentials">
+<polymer-element name="core-ajax" hidden attributes="url handleAs auto params response error method headers body contentType withCredentials progress loading">
 <script>
 
   Polymer('core-ajax', {
     /**
      * Fired when a response is received.
      *
      * @event core-response
      */
 
     /**
@@ skipping 53 matching lines @@
     /**
      * Parameters to send to the specified URL, as JSON.
      *
      * @attribute params
      * @type string (JSON)
      * @default ''
      */
     params: '',
 
     /**
-     * The response for the most recently made request, or null if it hasn't
+     * The response for the current request, or null if it hasn't
      * completed yet or the request resulted in error.
      *
      * @attribute response
      * @type Object
      * @default null
      */
     response: null,
 
     /**
-     * The error for the most recently made request, or null if it hasn't
+     * The error for the current request, or null if it hasn't
      * completed yet or the request resulted in success.
      *
      * @attribute error
      * @type Object
      * @default null
      */
     error: null,
 
     /**
+     * Whether the current request is currently loading.
+     *
+     * @attribute loading
+     * @type boolean
+     * @default false
+     */
+    loading: false,
+
+    /**
+     * The progress of the current request.
+     *
+     * @attribute progress
+     * @type {loaded: number, total: number, lengthComputable: boolean}
+     * @default {}
+     */
+    progress: null,
+
+    /**
      * The HTTP method to use such as 'GET', 'POST', 'PUT', or 'DELETE'.
      * Default is 'GET'.
      *
      * @attribute method
      * @type string
      * @default ''
      */
     method: '',
 
     /**
@@ skipping 53 matching lines @@
      * Can be set to an object containing default properties
      * to send as arguments to the `core-xhr.request()` method
      * which implements the low-level communication.
      *
      * @property xhrArgs
      * @type Object
      * @default null
      */
     xhrArgs: null,
 
+    created: function() {
+      this.progress = {};
+    },
+
     ready: function() {
       this.xhr = document.createElement('core-xhr');
     },
 
     receive: function(response, xhr) {
       if (this.isSuccess(xhr)) {
         this.processResponse(xhr);
       } else {
         this.processError(xhr);
       }
@@ skipping 14 matching lines @@
     },
 
     processError: function(xhr) {
       var response = xhr.status + ': ' + xhr.responseText;
       if (xhr === this.activeRequest) {
         this.error = response;
       }
       this.fire('core-error', {response: response, xhr: xhr});
     },
 
+    processProgress: function(progress, xhr) {
+      if (xhr !== this.activeRequest) {
+        return;
+      }
+      // We create a proxy object here because these fields
+      // on the progress event are readonly properties, which
+      // causes problems in common use cases (e.g. binding to
+      // <paper-progress> attributes).
+      var progressProxy = {
+        lengthComputable: progress.lengthComputable,
+        loaded: progress.loaded,
+        total: progress.total
+      }
+      this.progress = progressProxy;
+    },
+
     complete: function(xhr) {
+      if (xhr === this.activeRequest) {
+        this.loading = false;
+      }
       this.fire('core-complete', {response: xhr.status, xhr: xhr});
     },
 
     evalResponse: function(xhr) {
       return this[(this.handleAs || 'text') + 'Handler'](xhr);
     },
 
     xmlHandler: function(xhr) {
       return xhr.responseXML;
     },
@@ skipping 35 matching lines @@
             break;
         }
       }
       this.autoGo();
     },
 
     paramsChanged: function() {
       this.autoGo();
     },
 
+    bodyChanged: function() {
+      this.autoGo();
+    },
+
     autoChanged: function() {
       this.autoGo();
     },
 
     // TODO(sorvell): multiple side-effects could call autoGo
     // during one micro-task, use a job to have only one action
     // occur
     autoGo: function() {
       if (this.auto) {
         this.goJob = this.job(this.goJob, this.go, 0);
@@ skipping 13 matching lines @@
       if (args.params && typeof(args.params) == 'string') {
         args.params = JSON.parse(args.params);
       }
       args.headers = this.headers || args.headers || {};
       if (args.headers && typeof(args.headers) == 'string') {
         args.headers = JSON.parse(args.headers);
       }
       var hasContentType = Object.keys(args.headers).some(function (header) {
         return header.toLowerCase() === 'content-type';
       });
-      if (!hasContentType && this.contentType) {
+      // No Content-Type should be specified if sending `FormData`.  
+      // The UA must set the Content-Type w/ a calculated  multipart boundary ID.
+      if (args.body instanceof FormData) {
+        delete args.headers['Content-Type'];
+      } 
+      else if (!hasContentType && this.contentType) {
         args.headers['Content-Type'] = this.contentType;
       }
       if (this.handleAs === 'arraybuffer' || this.handleAs === 'blob' ||
           this.handleAs === 'document') {
         args.responseType = this.handleAs;
       }
       args.withCredentials = this.withCredentials;
       args.callback = this.receive.bind(this);
       args.url = this.url;
       args.method = this.method;
 
-      this.response = this.error = null;
+      this.response = this.error = this.progress = null;
       this.activeRequest = args.url && this.xhr.request(args);
+      if (this.activeRequest) {
+        this.loading = true;
+        var activeRequest = this.activeRequest;
+        // IE < 10 doesn't support progress events.
+        if ('onprogress' in activeRequest) {
+          this.activeRequest.addEventListener(
+              'progress',
+              function(progress) {
+                this.processProgress(progress, activeRequest);
+              }.bind(this), false);
+        } else {
+          this.progress = {
+            lengthComputable: false,
+          }
+        }
+      }
       return this.activeRequest;
     }
 
   });
 
 </script>
 </polymer-element>