summaryrefslogtreecommitdiffstats
path: root/node_modules/stream-http/lib
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/stream-http/lib')
-rw-r--r--node_modules/stream-http/lib/capability.js73
-rw-r--r--node_modules/stream-http/lib/request.js327
-rw-r--r--node_modules/stream-http/lib/response.js224
3 files changed, 624 insertions, 0 deletions
diff --git a/node_modules/stream-http/lib/capability.js b/node_modules/stream-http/lib/capability.js
new file mode 100644
index 0000000..3a17334
--- /dev/null
+++ b/node_modules/stream-http/lib/capability.js
@@ -0,0 +1,73 @@
+exports.fetch = isFunction(global.fetch) && isFunction(global.ReadableStream)
+
+exports.writableStream = isFunction(global.WritableStream)
+
+exports.abortController = isFunction(global.AbortController)
+
+exports.blobConstructor = false
+try {
+ new Blob([new ArrayBuffer(1)])
+ exports.blobConstructor = true
+} catch (e) {}
+
+// The xhr request to example.com may violate some restrictive CSP configurations,
+// so if we're running in a browser that supports `fetch`, avoid calling getXHR()
+// and assume support for certain features below.
+var xhr
+function getXHR () {
+ // Cache the xhr value
+ if (xhr !== undefined) return xhr
+
+ if (global.XMLHttpRequest) {
+ xhr = new global.XMLHttpRequest()
+ // If XDomainRequest is available (ie only, where xhr might not work
+ // cross domain), use the page location. Otherwise use example.com
+ // Note: this doesn't actually make an http request.
+ try {
+ xhr.open('GET', global.XDomainRequest ? '/' : 'https://example.com')
+ } catch(e) {
+ xhr = null
+ }
+ } else {
+ // Service workers don't have XHR
+ xhr = null
+ }
+ return xhr
+}
+
+function checkTypeSupport (type) {
+ var xhr = getXHR()
+ if (!xhr) return false
+ try {
+ xhr.responseType = type
+ return xhr.responseType === type
+ } catch (e) {}
+ return false
+}
+
+// For some strange reason, Safari 7.0 reports typeof global.ArrayBuffer === 'object'.
+// Safari 7.1 appears to have fixed this bug.
+var haveArrayBuffer = typeof global.ArrayBuffer !== 'undefined'
+var haveSlice = haveArrayBuffer && isFunction(global.ArrayBuffer.prototype.slice)
+
+// If fetch is supported, then arraybuffer will be supported too. Skip calling
+// checkTypeSupport(), since that calls getXHR().
+exports.arraybuffer = exports.fetch || (haveArrayBuffer && checkTypeSupport('arraybuffer'))
+
+// These next two tests unavoidably show warnings in Chrome. Since fetch will always
+// be used if it's available, just return false for these to avoid the warnings.
+exports.msstream = !exports.fetch && haveSlice && checkTypeSupport('ms-stream')
+exports.mozchunkedarraybuffer = !exports.fetch && haveArrayBuffer &&
+ checkTypeSupport('moz-chunked-arraybuffer')
+
+// If fetch is supported, then overrideMimeType will be supported too. Skip calling
+// getXHR().
+exports.overrideMimeType = exports.fetch || (getXHR() ? isFunction(getXHR().overrideMimeType) : false)
+
+exports.vbArray = isFunction(global.VBArray)
+
+function isFunction (value) {
+ return typeof value === 'function'
+}
+
+xhr = null // Help gc
diff --git a/node_modules/stream-http/lib/request.js b/node_modules/stream-http/lib/request.js
new file mode 100644
index 0000000..4f097df
--- /dev/null
+++ b/node_modules/stream-http/lib/request.js
@@ -0,0 +1,327 @@
+var capability = require('./capability')
+var inherits = require('inherits')
+var response = require('./response')
+var stream = require('readable-stream')
+var toArrayBuffer = require('to-arraybuffer')
+
+var IncomingMessage = response.IncomingMessage
+var rStates = response.readyStates
+
+function decideMode (preferBinary, useFetch) {
+ if (capability.fetch && useFetch) {
+ return 'fetch'
+ } else if (capability.mozchunkedarraybuffer) {
+ return 'moz-chunked-arraybuffer'
+ } else if (capability.msstream) {
+ return 'ms-stream'
+ } else if (capability.arraybuffer && preferBinary) {
+ return 'arraybuffer'
+ } else if (capability.vbArray && preferBinary) {
+ return 'text:vbarray'
+ } else {
+ return 'text'
+ }
+}
+
+var ClientRequest = module.exports = function (opts) {
+ var self = this
+ stream.Writable.call(self)
+
+ self._opts = opts
+ self._body = []
+ self._headers = {}
+ if (opts.auth)
+ self.setHeader('Authorization', 'Basic ' + new Buffer(opts.auth).toString('base64'))
+ Object.keys(opts.headers).forEach(function (name) {
+ self.setHeader(name, opts.headers[name])
+ })
+
+ var preferBinary
+ var useFetch = true
+ if (opts.mode === 'disable-fetch' || ('requestTimeout' in opts && !capability.abortController)) {
+ // If the use of XHR should be preferred. Not typically needed.
+ useFetch = false
+ preferBinary = true
+ } else if (opts.mode === 'prefer-streaming') {
+ // If streaming is a high priority but binary compatibility and
+ // the accuracy of the 'content-type' header aren't
+ preferBinary = false
+ } else if (opts.mode === 'allow-wrong-content-type') {
+ // If streaming is more important than preserving the 'content-type' header
+ preferBinary = !capability.overrideMimeType
+ } else if (!opts.mode || opts.mode === 'default' || opts.mode === 'prefer-fast') {
+ // Use binary if text streaming may corrupt data or the content-type header, or for speed
+ preferBinary = true
+ } else {
+ throw new Error('Invalid value for opts.mode')
+ }
+ self._mode = decideMode(preferBinary, useFetch)
+ self._fetchTimer = null
+
+ self.on('finish', function () {
+ self._onFinish()
+ })
+}
+
+inherits(ClientRequest, stream.Writable)
+
+ClientRequest.prototype.setHeader = function (name, value) {
+ var self = this
+ var lowerName = name.toLowerCase()
+ // This check is not necessary, but it prevents warnings from browsers about setting unsafe
+ // headers. To be honest I'm not entirely sure hiding these warnings is a good thing, but
+ // http-browserify did it, so I will too.
+ if (unsafeHeaders.indexOf(lowerName) !== -1)
+ return
+
+ self._headers[lowerName] = {
+ name: name,
+ value: value
+ }
+}
+
+ClientRequest.prototype.getHeader = function (name) {
+ var header = this._headers[name.toLowerCase()]
+ if (header)
+ return header.value
+ return null
+}
+
+ClientRequest.prototype.removeHeader = function (name) {
+ var self = this
+ delete self._headers[name.toLowerCase()]
+}
+
+ClientRequest.prototype._onFinish = function () {
+ var self = this
+
+ if (self._destroyed)
+ return
+ var opts = self._opts
+
+ var headersObj = self._headers
+ var body = null
+ if (opts.method !== 'GET' && opts.method !== 'HEAD') {
+ if (capability.arraybuffer) {
+ body = toArrayBuffer(Buffer.concat(self._body))
+ } else if (capability.blobConstructor) {
+ body = new global.Blob(self._body.map(function (buffer) {
+ return toArrayBuffer(buffer)
+ }), {
+ type: (headersObj['content-type'] || {}).value || ''
+ })
+ } else {
+ // get utf8 string
+ body = Buffer.concat(self._body).toString()
+ }
+ }
+
+ // create flattened list of headers
+ var headersList = []
+ Object.keys(headersObj).forEach(function (keyName) {
+ var name = headersObj[keyName].name
+ var value = headersObj[keyName].value
+ if (Array.isArray(value)) {
+ value.forEach(function (v) {
+ headersList.push([name, v])
+ })
+ } else {
+ headersList.push([name, value])
+ }
+ })
+
+ if (self._mode === 'fetch') {
+ var signal = null
+ var fetchTimer = null
+ if (capability.abortController) {
+ var controller = new AbortController()
+ signal = controller.signal
+ self._fetchAbortController = controller
+
+ if ('requestTimeout' in opts && opts.requestTimeout !== 0) {
+ self._fetchTimer = global.setTimeout(function () {
+ self.emit('requestTimeout')
+ if (self._fetchAbortController)
+ self._fetchAbortController.abort()
+ }, opts.requestTimeout)
+ }
+ }
+
+ global.fetch(self._opts.url, {
+ method: self._opts.method,
+ headers: headersList,
+ body: body || undefined,
+ mode: 'cors',
+ credentials: opts.withCredentials ? 'include' : 'same-origin',
+ signal: signal
+ }).then(function (response) {
+ self._fetchResponse = response
+ self._connect()
+ }, function (reason) {
+ global.clearTimeout(self._fetchTimer)
+ if (!self._destroyed)
+ self.emit('error', reason)
+ })
+ } else {
+ var xhr = self._xhr = new global.XMLHttpRequest()
+ try {
+ xhr.open(self._opts.method, self._opts.url, true)
+ } catch (err) {
+ process.nextTick(function () {
+ self.emit('error', err)
+ })
+ return
+ }
+
+ // Can't set responseType on really old browsers
+ if ('responseType' in xhr)
+ xhr.responseType = self._mode.split(':')[0]
+
+ if ('withCredentials' in xhr)
+ xhr.withCredentials = !!opts.withCredentials
+
+ if (self._mode === 'text' && 'overrideMimeType' in xhr)
+ xhr.overrideMimeType('text/plain; charset=x-user-defined')
+
+ if ('requestTimeout' in opts) {
+ xhr.timeout = opts.requestTimeout
+ xhr.ontimeout = function () {
+ self.emit('requestTimeout')
+ }
+ }
+
+ headersList.forEach(function (header) {
+ xhr.setRequestHeader(header[0], header[1])
+ })
+
+ self._response = null
+ xhr.onreadystatechange = function () {
+ switch (xhr.readyState) {
+ case rStates.LOADING:
+ case rStates.DONE:
+ self._onXHRProgress()
+ break
+ }
+ }
+ // Necessary for streaming in Firefox, since xhr.response is ONLY defined
+ // in onprogress, not in onreadystatechange with xhr.readyState = 3
+ if (self._mode === 'moz-chunked-arraybuffer') {
+ xhr.onprogress = function () {
+ self._onXHRProgress()
+ }
+ }
+
+ xhr.onerror = function () {
+ if (self._destroyed)
+ return
+ self.emit('error', new Error('XHR error'))
+ }
+
+ try {
+ xhr.send(body)
+ } catch (err) {
+ process.nextTick(function () {
+ self.emit('error', err)
+ })
+ return
+ }
+ }
+}
+
+/**
+ * Checks if xhr.status is readable and non-zero, indicating no error.
+ * Even though the spec says it should be available in readyState 3,
+ * accessing it throws an exception in IE8
+ */
+function statusValid (xhr) {
+ try {
+ var status = xhr.status
+ return (status !== null && status !== 0)
+ } catch (e) {
+ return false
+ }
+}
+
+ClientRequest.prototype._onXHRProgress = function () {
+ var self = this
+
+ if (!statusValid(self._xhr) || self._destroyed)
+ return
+
+ if (!self._response)
+ self._connect()
+
+ self._response._onXHRProgress()
+}
+
+ClientRequest.prototype._connect = function () {
+ var self = this
+
+ if (self._destroyed)
+ return
+
+ self._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode, self._fetchTimer)
+ self._response.on('error', function(err) {
+ self.emit('error', err)
+ })
+
+ self.emit('response', self._response)
+}
+
+ClientRequest.prototype._write = function (chunk, encoding, cb) {
+ var self = this
+
+ self._body.push(chunk)
+ cb()
+}
+
+ClientRequest.prototype.abort = ClientRequest.prototype.destroy = function () {
+ var self = this
+ self._destroyed = true
+ global.clearTimeout(self._fetchTimer)
+ if (self._response)
+ self._response._destroyed = true
+ if (self._xhr)
+ self._xhr.abort()
+ else if (self._fetchAbortController)
+ self._fetchAbortController.abort()
+}
+
+ClientRequest.prototype.end = function (data, encoding, cb) {
+ var self = this
+ if (typeof data === 'function') {
+ cb = data
+ data = undefined
+ }
+
+ stream.Writable.prototype.end.call(self, data, encoding, cb)
+}
+
+ClientRequest.prototype.flushHeaders = function () {}
+ClientRequest.prototype.setTimeout = function () {}
+ClientRequest.prototype.setNoDelay = function () {}
+ClientRequest.prototype.setSocketKeepAlive = function () {}
+
+// Taken from http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader%28%29-method
+var unsafeHeaders = [
+ 'accept-charset',
+ 'accept-encoding',
+ 'access-control-request-headers',
+ 'access-control-request-method',
+ 'connection',
+ 'content-length',
+ 'cookie',
+ 'cookie2',
+ 'date',
+ 'dnt',
+ 'expect',
+ 'host',
+ 'keep-alive',
+ 'origin',
+ 'referer',
+ 'te',
+ 'trailer',
+ 'transfer-encoding',
+ 'upgrade',
+ 'via'
+]
diff --git a/node_modules/stream-http/lib/response.js b/node_modules/stream-http/lib/response.js
new file mode 100644
index 0000000..17d1fb7
--- /dev/null
+++ b/node_modules/stream-http/lib/response.js
@@ -0,0 +1,224 @@
+var capability = require('./capability')
+var inherits = require('inherits')
+var stream = require('readable-stream')
+
+var rStates = exports.readyStates = {
+ UNSENT: 0,
+ OPENED: 1,
+ HEADERS_RECEIVED: 2,
+ LOADING: 3,
+ DONE: 4
+}
+
+var IncomingMessage = exports.IncomingMessage = function (xhr, response, mode, fetchTimer) {
+ var self = this
+ stream.Readable.call(self)
+
+ self._mode = mode
+ self.headers = {}
+ self.rawHeaders = []
+ self.trailers = {}
+ self.rawTrailers = []
+
+ // Fake the 'close' event, but only once 'end' fires
+ self.on('end', function () {
+ // The nextTick is necessary to prevent the 'request' module from causing an infinite loop
+ process.nextTick(function () {
+ self.emit('close')
+ })
+ })
+
+ if (mode === 'fetch') {
+ self._fetchResponse = response
+
+ self.url = response.url
+ self.statusCode = response.status
+ self.statusMessage = response.statusText
+
+ response.headers.forEach(function (header, key){
+ self.headers[key.toLowerCase()] = header
+ self.rawHeaders.push(key, header)
+ })
+
+ if (capability.writableStream) {
+ var writable = new WritableStream({
+ write: function (chunk) {
+ return new Promise(function (resolve, reject) {
+ if (self._destroyed) {
+ reject()
+ } else if(self.push(new Buffer(chunk))) {
+ resolve()
+ } else {
+ self._resumeFetch = resolve
+ }
+ })
+ },
+ close: function () {
+ global.clearTimeout(fetchTimer)
+ if (!self._destroyed)
+ self.push(null)
+ },
+ abort: function (err) {
+ if (!self._destroyed)
+ self.emit('error', err)
+ }
+ })
+
+ try {
+ response.body.pipeTo(writable).catch(function (err) {
+ global.clearTimeout(fetchTimer)
+ if (!self._destroyed)
+ self.emit('error', err)
+ })
+ return
+ } catch (e) {} // pipeTo method isn't defined. Can't find a better way to feature test this
+ }
+ // fallback for when writableStream or pipeTo aren't available
+ var reader = response.body.getReader()
+ function read () {
+ reader.read().then(function (result) {
+ if (self._destroyed)
+ return
+ if (result.done) {
+ global.clearTimeout(fetchTimer)
+ self.push(null)
+ return
+ }
+ self.push(new Buffer(result.value))
+ read()
+ }).catch(function (err) {
+ global.clearTimeout(fetchTimer)
+ if (!self._destroyed)
+ self.emit('error', err)
+ })
+ }
+ read()
+ } else {
+ self._xhr = xhr
+ self._pos = 0
+
+ self.url = xhr.responseURL
+ self.statusCode = xhr.status
+ self.statusMessage = xhr.statusText
+ var headers = xhr.getAllResponseHeaders().split(/\r?\n/)
+ headers.forEach(function (header) {
+ var matches = header.match(/^([^:]+):\s*(.*)/)
+ if (matches) {
+ var key = matches[1].toLowerCase()
+ if (key === 'set-cookie') {
+ if (self.headers[key] === undefined) {
+ self.headers[key] = []
+ }
+ self.headers[key].push(matches[2])
+ } else if (self.headers[key] !== undefined) {
+ self.headers[key] += ', ' + matches[2]
+ } else {
+ self.headers[key] = matches[2]
+ }
+ self.rawHeaders.push(matches[1], matches[2])
+ }
+ })
+
+ self._charset = 'x-user-defined'
+ if (!capability.overrideMimeType) {
+ var mimeType = self.rawHeaders['mime-type']
+ if (mimeType) {
+ var charsetMatch = mimeType.match(/;\s*charset=([^;])(;|$)/)
+ if (charsetMatch) {
+ self._charset = charsetMatch[1].toLowerCase()
+ }
+ }
+ if (!self._charset)
+ self._charset = 'utf-8' // best guess
+ }
+ }
+}
+
+inherits(IncomingMessage, stream.Readable)
+
+IncomingMessage.prototype._read = function () {
+ var self = this
+
+ var resolve = self._resumeFetch
+ if (resolve) {
+ self._resumeFetch = null
+ resolve()
+ }
+}
+
+IncomingMessage.prototype._onXHRProgress = function () {
+ var self = this
+
+ var xhr = self._xhr
+
+ var response = null
+ switch (self._mode) {
+ case 'text:vbarray': // For IE9
+ if (xhr.readyState !== rStates.DONE)
+ break
+ try {
+ // This fails in IE8
+ response = new global.VBArray(xhr.responseBody).toArray()
+ } catch (e) {}
+ if (response !== null) {
+ self.push(new Buffer(response))
+ break
+ }
+ // Falls through in IE8
+ case 'text':
+ try { // This will fail when readyState = 3 in IE9. Switch mode and wait for readyState = 4
+ response = xhr.responseText
+ } catch (e) {
+ self._mode = 'text:vbarray'
+ break
+ }
+ if (response.length > self._pos) {
+ var newData = response.substr(self._pos)
+ if (self._charset === 'x-user-defined') {
+ var buffer = new Buffer(newData.length)
+ for (var i = 0; i < newData.length; i++)
+ buffer[i] = newData.charCodeAt(i) & 0xff
+
+ self.push(buffer)
+ } else {
+ self.push(newData, self._charset)
+ }
+ self._pos = response.length
+ }
+ break
+ case 'arraybuffer':
+ if (xhr.readyState !== rStates.DONE || !xhr.response)
+ break
+ response = xhr.response
+ self.push(new Buffer(new Uint8Array(response)))
+ break
+ case 'moz-chunked-arraybuffer': // take whole
+ response = xhr.response
+ if (xhr.readyState !== rStates.LOADING || !response)
+ break
+ self.push(new Buffer(new Uint8Array(response)))
+ break
+ case 'ms-stream':
+ response = xhr.response
+ if (xhr.readyState !== rStates.LOADING)
+ break
+ var reader = new global.MSStreamReader()
+ reader.onprogress = function () {
+ if (reader.result.byteLength > self._pos) {
+ self.push(new Buffer(new Uint8Array(reader.result.slice(self._pos))))
+ self._pos = reader.result.byteLength
+ }
+ }
+ reader.onload = function () {
+ self.push(null)
+ }
+ // reader.onerror = ??? // TODO: this
+ reader.readAsArrayBuffer(response)
+ break
+ }
+
+ // The ms-stream case handles end separately in reader.onload()
+ if (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') {
+ self.push(null)
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-23 13:39:46 +0000