| 1 |
import {overrideMimeType} from './capability'; |
| 2 |
import {inherits} from 'util'; |
| 3 |
import {Readable} from 'stream'; |
| 4 |
|
| 5 |
var rStates = { |
| 6 |
UNSENT: 0, |
| 7 |
OPENED: 1, |
| 8 |
HEADERS_RECEIVED: 2, |
| 9 |
LOADING: 3, |
| 10 |
DONE: 4 |
| 11 |
} |
| 12 |
export { |
| 13 |
rStates as readyStates |
| 14 |
}; |
| 15 |
export function IncomingMessage(xhr, response, mode) { |
| 16 |
var self = this |
| 17 |
Readable.call(self) |
| 18 |
|
| 19 |
self._mode = mode |
| 20 |
self.headers = {} |
| 21 |
self.rawHeaders = [] |
| 22 |
self.trailers = {} |
| 23 |
self.rawTrailers = [] |
| 24 |
|
| 25 |
// Fake the 'close' event, but only once 'end' fires |
| 26 |
self.on('end', function() { |
| 27 |
// The nextTick is necessary to prevent the 'request' module from causing an infinite loop |
| 28 |
process.nextTick(function() { |
| 29 |
self.emit('close') |
| 30 |
}) |
| 31 |
}) |
| 32 |
var read; |
| 33 |
if (mode === 'fetch') { |
| 34 |
self._fetchResponse = response |
| 35 |
|
| 36 |
self.url = response.url |
| 37 |
self.statusCode = response.status |
| 38 |
self.statusMessage = response.statusText |
| 39 |
// backwards compatible version of for (<item> of <iterable>): |
| 40 |
// for (var <item>,_i,_it = <iterable>[Symbol.iterator](); <item> = (_i = _it.next()).value,!_i.done;) |
| 41 |
for (var header, _i, _it = response.headers[Symbol.iterator](); header = (_i = _it.next()).value, !_i.done;) { |
| 42 |
self.headers[header[0].toLowerCase()] = header[1] |
| 43 |
self.rawHeaders.push(header[0], header[1]) |
| 44 |
} |
| 45 |
|
| 46 |
// TODO: this doesn't respect backpressure. Once WritableStream is available, this can be fixed |
| 47 |
var reader = response.body.getReader() |
| 48 |
|
| 49 |
read = function () { |
| 50 |
reader.read().then(function(result) { |
| 51 |
if (self._destroyed) |
| 52 |
return |
| 53 |
if (result.done) { |
| 54 |
self.push(null) |
| 55 |
return |
| 56 |
} |
| 57 |
self.push(new Buffer(result.value)) |
| 58 |
read() |
| 59 |
}) |
| 60 |
} |
| 61 |
read() |
| 62 |
|
| 63 |
} else { |
| 64 |
self._xhr = xhr |
| 65 |
self._pos = 0 |
| 66 |
|
| 67 |
self.url = xhr.responseURL |
| 68 |
self.statusCode = xhr.status |
| 69 |
self.statusMessage = xhr.statusText |
| 70 |
var headers = xhr.getAllResponseHeaders().split(/\r?\n/) |
| 71 |
headers.forEach(function(header) { |
| 72 |
var matches = header.match(/^([^:]+):\s*(.*)/) |
| 73 |
if (matches) { |
| 74 |
var key = matches[1].toLowerCase() |
| 75 |
if (key === 'set-cookie') { |
| 76 |
if (self.headers[key] === undefined) { |
| 77 |
self.headers[key] = [] |
| 78 |
} |
| 79 |
self.headers[key].push(matches[2]) |
| 80 |
} else if (self.headers[key] !== undefined) { |
| 81 |
self.headers[key] += ', ' + matches[2] |
| 82 |
} else { |
| 83 |
self.headers[key] = matches[2] |
| 84 |
} |
| 85 |
self.rawHeaders.push(matches[1], matches[2]) |
| 86 |
} |
| 87 |
}) |
| 88 |
|
| 89 |
self._charset = 'x-user-defined' |
| 90 |
if (!overrideMimeType) { |
| 91 |
var mimeType = self.rawHeaders['mime-type'] |
| 92 |
if (mimeType) { |
| 93 |
var charsetMatch = mimeType.match(/;\s*charset=([^;])(;|$)/) |
| 94 |
if (charsetMatch) { |
| 95 |
self._charset = charsetMatch[1].toLowerCase() |
| 96 |
} |
| 97 |
} |
| 98 |
if (!self._charset) |
| 99 |
self._charset = 'utf-8' // best guess |
| 100 |
} |
| 101 |
} |
| 102 |
} |
| 103 |
|
| 104 |
inherits(IncomingMessage, Readable) |
| 105 |
|
| 106 |
IncomingMessage.prototype._read = function() {} |
| 107 |
|
| 108 |
IncomingMessage.prototype._onXHRProgress = function() { |
| 109 |
var self = this |
| 110 |
|
| 111 |
var xhr = self._xhr |
| 112 |
|
| 113 |
var response = null |
| 114 |
switch (self._mode) { |
| 115 |
case 'text:vbarray': // For IE9 |
| 116 |
if (xhr.readyState !== rStates.DONE) |
| 117 |
break |
| 118 |
try { |
| 119 |
// This fails in IE8 |
| 120 |
response = new global.VBArray(xhr.responseBody).toArray() |
| 121 |
} catch (e) { |
| 122 |
// pass |
| 123 |
} |
| 124 |
if (response !== null) { |
| 125 |
self.push(new Buffer(response)) |
| 126 |
break |
| 127 |
} |
| 128 |
// Falls through in IE8 |
| 129 |
case 'text': |
| 130 |
try { // This will fail when readyState = 3 in IE9. Switch mode and wait for readyState = 4 |
| 131 |
response = xhr.responseText |
| 132 |
} catch (e) { |
| 133 |
self._mode = 'text:vbarray' |
| 134 |
break |
| 135 |
} |
| 136 |
if (response.length > self._pos) { |
| 137 |
var newData = response.substr(self._pos) |
| 138 |
if (self._charset === 'x-user-defined') { |
| 139 |
var buffer = new Buffer(newData.length) |
| 140 |
for (var i = 0; i < newData.length; i++) |
| 141 |
buffer[i] = newData.charCodeAt(i) & 0xff |
| 142 |
|
| 143 |
self.push(buffer) |
| 144 |
} else { |
| 145 |
self.push(newData, self._charset) |
| 146 |
} |
| 147 |
self._pos = response.length |
| 148 |
} |
| 149 |
break |
| 150 |
case 'arraybuffer': |
| 151 |
if (xhr.readyState !== rStates.DONE || !xhr.response) |
| 152 |
break |
| 153 |
response = xhr.response |
| 154 |
self.push(new Buffer(new Uint8Array(response))) |
| 155 |
break |
| 156 |
case 'moz-chunked-arraybuffer': // take whole |
| 157 |
response = xhr.response |
| 158 |
if (xhr.readyState !== rStates.LOADING || !response) |
| 159 |
break |
| 160 |
self.push(new Buffer(new Uint8Array(response))) |
| 161 |
break |
| 162 |
case 'ms-stream': |
| 163 |
response = xhr.response |
| 164 |
if (xhr.readyState !== rStates.LOADING) |
| 165 |
break |
| 166 |
var reader = new global.MSStreamReader() |
| 167 |
reader.onprogress = function() { |
| 168 |
if (reader.result.byteLength > self._pos) { |
| 169 |
self.push(new Buffer(new Uint8Array(reader.result.slice(self._pos)))) |
| 170 |
self._pos = reader.result.byteLength |
| 171 |
} |
| 172 |
} |
| 173 |
reader.onload = function() { |
| 174 |
self.push(null) |
| 175 |
} |
| 176 |
// reader.onerror = ??? // TODO: this |
| 177 |
reader.readAsArrayBuffer(response) |
| 178 |
break |
| 179 |
} |
| 180 |
|
| 181 |
// The ms-stream case handles end separately in reader.onload() |
| 182 |
if (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') { |
| 183 |
self.push(null) |
| 184 |
} |
| 185 |
} |