experimental: use request/request instead of built-in things to implement following redirects etc

Author: tchakabam

lib/index.js

@@ -8,11 +8,21 @@
  */
 
 var url = require('url');
-var http = require('http');
-var https = require('https');
+var http = require('follow-redirects').http; // Drop-in replacement for Nodes http and https that automatically follows redirects.
+var https = require('follow-redirects').https;
+var request = require('request');
 
 var NodeXHREventTarget = require('./node-xhr-event-target');
 
+function utf8StringToArray(str) {
+  var buf = new ArrayBuffer(str.length); // 2 bytes for each char
+  var bufView = new Uint8Array(buf);
+  for (var i=0, strLen=str.length; i < strLen; i++) {
+    bufView[i] = str.charCodeAt(i);
+  }
+  return buf;
+}
+
 /**
  * Currently-supported response types.
  *
@@ -38,16 +48,26 @@ var supportedResponseTypes = Object.freeze({
  * @private
  * @param {Object} opts - Options for the request.
  * @param {Function} cb - Callback for request.
- * @returns {ClientRequest} The request.
  */
 function makeRequest(opts, cb) {
-  if (opts.protocol === 'http:') {
-    return http.request(opts, cb);
-  } else if (opts.protocol === 'https:') {
-    return https.request(opts, cb);
-  }
+  opts.gzip = true;
+  return request(opts, cb)
+}
 
-  throw new Error('Unsupported protocol "' + opts.protcol + '"');
+/**
+ * @param {NodeRequestOptions} opts
+ * @param {string} reqUrl
+ */
+function setUrl(opts, reqUrl) {
+  var urlObj = url.parse(reqUrl);
+  /*
+  ['protocol', 'hostname', 'port', 'path'].forEach(function (key) {
+    if (key in urlObj) {
+      opts[key] = urlObj[key];
+    }
+  });
+  */
+ opts.url = urlObj;
 }
 
 /**
@@ -436,12 +456,7 @@ NodeHttpXHR.prototype.open = function (method, reqUrl, async) {
   var opts = this._reqOpts;
   opts.method = method;
 
-  var urlObj = url.parse(reqUrl);
-  ['protocol', 'hostname', 'port', 'path'].forEach(function (key) {
-    if (key in urlObj) {
-      opts[key] = urlObj[key];
-    }
-  });
+  setUrl(opts, reqUrl);
 
   this._setReadyState(this.OPENED);
 };
@@ -496,52 +511,94 @@ NodeHttpXHR.prototype.send = function (data) {
   }.bind(this);
 
   var opts = this._reqOpts;
-  var req = makeRequest(opts, function onResponse(resp) {
+
+  var req = makeRequest(opts, function onResponse(err, resp, body) {
+
+    if (this.readyState !== this.LOADING) {
+      this._setReadyState(this.LOADING);
+    }
+
+    if (err) {
+      if (this._listenerCount('error') < 1) {
+        // Uncaught error; throw something more meaningful
+        throw err;
+      }
+
+      // Dispatch an error event. The specification does not provide for any way
+      // to communicate the failure reason with the event object.
+      this.dispatchEvent({
+        type: 'error'
+      });
+
+      this._setReadyState(this.DONE);
+      return;
+    }
+
     this._resp = resp;
     this._responseText = '';
+    this._response = null;
+
+    if (typeof body === 'string') {
+      this._responseText = body;
+    } else if (typeof body === 'object') {
+      if (!(body instanceof Buffer)) {
+        throw new Error('Assertion failed: Response-data should be of `Buffer` type');
+      }
+      this._response = body;
+    }
+
+    if (this._responseType === 'arraybuffer' && this._responseText) {
+      this._response = Buffer.from(utf8StringToArray(this._responseText));
+    }
 
     // var contentType = resp.headers['content-type'];
     // TODO: adjust responseType from content-type header if applicable
 
     // from Node API docs: The encoding argument is optional and only applies when chunk is a string. Defaults to 'utf8'.
+    /*
     if (this._responseType === 'text' || this._responseType === '') {
       resp.setEncoding('utf8');
     }
+    */
 
-    resp.on('data', function onData(chunk) {
+    this._setReadyState(this.HEADERS_RECEIVED);
 
-      if (typeof chunk === 'string') {
-        this._responseText += chunk;
-      } else if (typeof chunk === 'object') {
-        if (!(chunk instanceof Buffer)) {
-          throw new Error('Assertion failed: Response-data should be of `Buffer` type');
-        }
-        if (this._response) {
-          this._response = Buffer.concat([this._response, chunk]);
-        } else {
-          this._response = chunk;
-        }
-      }
+    this._setReadyState(this.DONE);
 
-      if (this.readyState !== this.LOADING) {
-        this._setReadyState(this.LOADING);
-      }
+    this.dispatchEvent({
+      type: 'load'
+    });
 
-    }.bind(this));
 
-    resp.on('end', function onEnd() {
-      this._setReadyState(this.DONE);
-      this.dispatchEvent({
-        type: 'load'
-      });
-    }.bind(this));
+  }.bind(this));
 
-    this._setReadyState(this.HEADERS_RECEIVED);
+  /*
+  req.on('data', function onData(chunk) {
+
+    if (typeof chunk === 'string') {
+      this._responseText += chunk;
+    } else if (typeof chunk === 'object') {
+      if (!(chunk instanceof Buffer)) {
+        throw new Error('Assertion failed: Response-data should be of `Buffer` type');
+      }
+      if (this._response) {
+        this._response = Buffer.concat([this._response, chunk]);
+      } else {
+        this._response = chunk;
+      }
+    }
+
+    if (this.readyState !== this.LOADING) {
+      this._setReadyState(this.LOADING);
+    }
   }.bind(this));
+  */
 
   // Passing `opts.timeout` doesn't actually seem to set the timeout sometimes,
   // so it is set manually here.
-  req.setTimeout(opts.timeout);
+  //req.setTimeout(opts.timeout);
+
+  /*
 
   req.on('abort', onAbort);
   req.on('aborted', onAbort);
@@ -568,11 +625,14 @@ NodeHttpXHR.prototype.send = function (data) {
     this._setReadyState(this.DONE);
   }.bind(this));
 
+
   if (data) {
     req.write(data);
   }
   req.end();
 
+  */
+
   this._req = req;
 };