1516 строки
30 KiB
JavaScript
1516 строки
30 KiB
JavaScript
;(function(){
|
|
|
|
/**
|
|
* Require the given path.
|
|
*
|
|
* @param {String} path
|
|
* @return {Object} exports
|
|
* @api public
|
|
*/
|
|
|
|
function require(path, parent, orig) {
|
|
var resolved = require.resolve(path);
|
|
|
|
// lookup failed
|
|
if (null == resolved) {
|
|
orig = orig || path;
|
|
parent = parent || 'root';
|
|
var err = new Error('Failed to require "' + orig + '" from "' + parent + '"');
|
|
err.path = orig;
|
|
err.parent = parent;
|
|
err.require = true;
|
|
throw err;
|
|
}
|
|
|
|
var module = require.modules[resolved];
|
|
|
|
// perform real require()
|
|
// by invoking the module's
|
|
// registered function
|
|
if (!module._resolving && !module.exports) {
|
|
var mod = {};
|
|
mod.exports = {};
|
|
mod.client = mod.component = true;
|
|
module._resolving = true;
|
|
module.call(this, mod.exports, require.relative(resolved), mod);
|
|
delete module._resolving;
|
|
module.exports = mod.exports;
|
|
}
|
|
|
|
return module.exports;
|
|
}
|
|
|
|
/**
|
|
* Registered modules.
|
|
*/
|
|
|
|
require.modules = {};
|
|
|
|
/**
|
|
* Registered aliases.
|
|
*/
|
|
|
|
require.aliases = {};
|
|
|
|
/**
|
|
* Resolve `path`.
|
|
*
|
|
* Lookup:
|
|
*
|
|
* - PATH/index.js
|
|
* - PATH.js
|
|
* - PATH
|
|
*
|
|
* @param {String} path
|
|
* @return {String} path or null
|
|
* @api private
|
|
*/
|
|
|
|
require.resolve = function(path) {
|
|
if (path.charAt(0) === '/') path = path.slice(1);
|
|
|
|
var paths = [
|
|
path,
|
|
path + '.js',
|
|
path + '.json',
|
|
path + '/index.js',
|
|
path + '/index.json'
|
|
];
|
|
|
|
for (var i = 0; i < paths.length; i++) {
|
|
var path = paths[i];
|
|
if (require.modules.hasOwnProperty(path)) return path;
|
|
if (require.aliases.hasOwnProperty(path)) return require.aliases[path];
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Normalize `path` relative to the current path.
|
|
*
|
|
* @param {String} curr
|
|
* @param {String} path
|
|
* @return {String}
|
|
* @api private
|
|
*/
|
|
|
|
require.normalize = function(curr, path) {
|
|
var segs = [];
|
|
|
|
if ('.' != path.charAt(0)) return path;
|
|
|
|
curr = curr.split('/');
|
|
path = path.split('/');
|
|
|
|
for (var i = 0; i < path.length; ++i) {
|
|
if ('..' == path[i]) {
|
|
curr.pop();
|
|
} else if ('.' != path[i] && '' != path[i]) {
|
|
segs.push(path[i]);
|
|
}
|
|
}
|
|
|
|
return curr.concat(segs).join('/');
|
|
};
|
|
|
|
/**
|
|
* Register module at `path` with callback `definition`.
|
|
*
|
|
* @param {String} path
|
|
* @param {Function} definition
|
|
* @api private
|
|
*/
|
|
|
|
require.register = function(path, definition) {
|
|
require.modules[path] = definition;
|
|
};
|
|
|
|
/**
|
|
* Alias a module definition.
|
|
*
|
|
* @param {String} from
|
|
* @param {String} to
|
|
* @api private
|
|
*/
|
|
|
|
require.alias = function(from, to) {
|
|
if (!require.modules.hasOwnProperty(from)) {
|
|
throw new Error('Failed to alias "' + from + '", it does not exist');
|
|
}
|
|
require.aliases[to] = from;
|
|
};
|
|
|
|
/**
|
|
* Return a require function relative to the `parent` path.
|
|
*
|
|
* @param {String} parent
|
|
* @return {Function}
|
|
* @api private
|
|
*/
|
|
|
|
require.relative = function(parent) {
|
|
var p = require.normalize(parent, '..');
|
|
|
|
/**
|
|
* lastIndexOf helper.
|
|
*/
|
|
|
|
function lastIndexOf(arr, obj) {
|
|
var i = arr.length;
|
|
while (i--) {
|
|
if (arr[i] === obj) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* The relative require() itself.
|
|
*/
|
|
|
|
function localRequire(path) {
|
|
var resolved = localRequire.resolve(path);
|
|
return require(resolved, parent, path);
|
|
}
|
|
|
|
/**
|
|
* Resolve relative to the parent.
|
|
*/
|
|
|
|
localRequire.resolve = function(path) {
|
|
var c = path.charAt(0);
|
|
if ('/' == c) return path.slice(1);
|
|
if ('.' == c) return require.normalize(p, path);
|
|
|
|
// resolve deps by returning
|
|
// the dep in the nearest "deps"
|
|
// directory
|
|
var segs = parent.split('/');
|
|
var i = lastIndexOf(segs, 'deps') + 1;
|
|
if (!i) i = 0;
|
|
path = segs.slice(0, i + 1).join('/') + '/deps/' + path;
|
|
return path;
|
|
};
|
|
|
|
/**
|
|
* Check if module is defined at `path`.
|
|
*/
|
|
|
|
localRequire.exists = function(path) {
|
|
return require.modules.hasOwnProperty(localRequire.resolve(path));
|
|
};
|
|
|
|
return localRequire;
|
|
};
|
|
require.register("component-emitter/index.js", function(exports, require, module){
|
|
|
|
/**
|
|
* Expose `Emitter`.
|
|
*/
|
|
|
|
module.exports = Emitter;
|
|
|
|
/**
|
|
* Initialize a new `Emitter`.
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
function Emitter(obj) {
|
|
if (obj) return mixin(obj);
|
|
};
|
|
|
|
/**
|
|
* Mixin the emitter properties.
|
|
*
|
|
* @param {Object} obj
|
|
* @return {Object}
|
|
* @api private
|
|
*/
|
|
|
|
function mixin(obj) {
|
|
for (var key in Emitter.prototype) {
|
|
obj[key] = Emitter.prototype[key];
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
/**
|
|
* Listen on the given `event` with `fn`.
|
|
*
|
|
* @param {String} event
|
|
* @param {Function} fn
|
|
* @return {Emitter}
|
|
* @api public
|
|
*/
|
|
|
|
Emitter.prototype.on =
|
|
Emitter.prototype.addEventListener = function(event, fn){
|
|
this._callbacks = this._callbacks || {};
|
|
(this._callbacks[event] = this._callbacks[event] || [])
|
|
.push(fn);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Adds an `event` listener that will be invoked a single
|
|
* time then automatically removed.
|
|
*
|
|
* @param {String} event
|
|
* @param {Function} fn
|
|
* @return {Emitter}
|
|
* @api public
|
|
*/
|
|
|
|
Emitter.prototype.once = function(event, fn){
|
|
var self = this;
|
|
this._callbacks = this._callbacks || {};
|
|
|
|
function on() {
|
|
self.off(event, on);
|
|
fn.apply(this, arguments);
|
|
}
|
|
|
|
on.fn = fn;
|
|
this.on(event, on);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Remove the given callback for `event` or all
|
|
* registered callbacks.
|
|
*
|
|
* @param {String} event
|
|
* @param {Function} fn
|
|
* @return {Emitter}
|
|
* @api public
|
|
*/
|
|
|
|
Emitter.prototype.off =
|
|
Emitter.prototype.removeListener =
|
|
Emitter.prototype.removeAllListeners =
|
|
Emitter.prototype.removeEventListener = function(event, fn){
|
|
this._callbacks = this._callbacks || {};
|
|
|
|
// all
|
|
if (0 == arguments.length) {
|
|
this._callbacks = {};
|
|
return this;
|
|
}
|
|
|
|
// specific event
|
|
var callbacks = this._callbacks[event];
|
|
if (!callbacks) return this;
|
|
|
|
// remove all handlers
|
|
if (1 == arguments.length) {
|
|
delete this._callbacks[event];
|
|
return this;
|
|
}
|
|
|
|
// remove specific handler
|
|
var cb;
|
|
for (var i = 0; i < callbacks.length; i++) {
|
|
cb = callbacks[i];
|
|
if (cb === fn || cb.fn === fn) {
|
|
callbacks.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Emit `event` with the given args.
|
|
*
|
|
* @param {String} event
|
|
* @param {Mixed} ...
|
|
* @return {Emitter}
|
|
*/
|
|
|
|
Emitter.prototype.emit = function(event){
|
|
this._callbacks = this._callbacks || {};
|
|
var args = [].slice.call(arguments, 1)
|
|
, callbacks = this._callbacks[event];
|
|
|
|
if (callbacks) {
|
|
callbacks = callbacks.slice(0);
|
|
for (var i = 0, len = callbacks.length; i < len; ++i) {
|
|
callbacks[i].apply(this, args);
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Return array of callbacks for `event`.
|
|
*
|
|
* @param {String} event
|
|
* @return {Array}
|
|
* @api public
|
|
*/
|
|
|
|
Emitter.prototype.listeners = function(event){
|
|
this._callbacks = this._callbacks || {};
|
|
return this._callbacks[event] || [];
|
|
};
|
|
|
|
/**
|
|
* Check if this emitter has `event` handlers.
|
|
*
|
|
* @param {String} event
|
|
* @return {Boolean}
|
|
* @api public
|
|
*/
|
|
|
|
Emitter.prototype.hasListeners = function(event){
|
|
return !! this.listeners(event).length;
|
|
};
|
|
|
|
});
|
|
require.register("component-reduce/index.js", function(exports, require, module){
|
|
|
|
/**
|
|
* Reduce `arr` with `fn`.
|
|
*
|
|
* @param {Array} arr
|
|
* @param {Function} fn
|
|
* @param {Mixed} initial
|
|
*
|
|
* TODO: combatible error handling?
|
|
*/
|
|
|
|
module.exports = function(arr, fn, initial){
|
|
var idx = 0;
|
|
var len = arr.length;
|
|
var curr = arguments.length == 3
|
|
? initial
|
|
: arr[idx++];
|
|
|
|
while (idx < len) {
|
|
curr = fn.call(null, curr, arr[idx], ++idx, arr);
|
|
}
|
|
|
|
return curr;
|
|
};
|
|
});
|
|
require.register("superagent/lib/client.js", function(exports, require, module){
|
|
/**
|
|
* Module dependencies.
|
|
*/
|
|
|
|
var Emitter = require('emitter');
|
|
var reduce = require('reduce');
|
|
|
|
/**
|
|
* Root reference for iframes.
|
|
*/
|
|
|
|
var root = 'undefined' == typeof window
|
|
? this
|
|
: window;
|
|
|
|
/**
|
|
* Noop.
|
|
*/
|
|
|
|
function noop(){};
|
|
|
|
/**
|
|
* Check if `obj` is a host object,
|
|
* we don't want to serialize these :)
|
|
*
|
|
* TODO: future proof, move to compoent land
|
|
*
|
|
* @param {Object} obj
|
|
* @return {Boolean}
|
|
* @api private
|
|
*/
|
|
|
|
function isHost(obj) {
|
|
var str = {}.toString.call(obj);
|
|
|
|
switch (str) {
|
|
case '[object File]':
|
|
case '[object Blob]':
|
|
case '[object FormData]':
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determine XHR.
|
|
*/
|
|
|
|
function getXHR(isXDomainRequest) {
|
|
if (isXDomainRequest === true) {
|
|
if (typeof new XMLHttpRequest().withCredentials !== 'undefined') {
|
|
// Check if the XMLHttpRequest object has a "withCredentials" property.
|
|
// "withCredentials" only exists on XMLHTTPRequest2 objects.
|
|
|
|
return new XMLHttpRequest();
|
|
} else if (typeof XDomainRequest !== "undefined") {
|
|
// Otherwise, check if XDomainRequest.
|
|
// XDomainRequest only exists in IE, and is IE's way of making CORS requests.
|
|
|
|
return new XDomainRequest();
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
if (root.XMLHttpRequest
|
|
&& ('file:' != root.location.protocol || !root.ActiveXObject)) {
|
|
return new XMLHttpRequest();
|
|
} else {
|
|
try { return new ActiveXObject('Microsoft.XMLHTTP'); } catch(e) {}
|
|
try { return new ActiveXObject('Msxml2.XMLHTTP.6.0'); } catch(e) {}
|
|
try { return new ActiveXObject('Msxml2.XMLHTTP.3.0'); } catch(e) {}
|
|
try { return new ActiveXObject('Msxml2.XMLHTTP'); } catch(e) {}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Removes leading and trailing whitespace, added to support IE.
|
|
*
|
|
* @param {String} s
|
|
* @return {String}
|
|
* @api private
|
|
*/
|
|
|
|
var trim = ''.trim
|
|
? function(s) { return s.trim(); }
|
|
: function(s) { return s.replace(/(^\s*|\s*$)/g, ''); };
|
|
|
|
/**
|
|
* Check if `obj` is an object.
|
|
*
|
|
* @param {Object} obj
|
|
* @return {Boolean}
|
|
* @api private
|
|
*/
|
|
|
|
function isObject(obj) {
|
|
return obj === Object(obj);
|
|
}
|
|
|
|
/**
|
|
* Serialize the given `obj`.
|
|
*
|
|
* @param {Object} obj
|
|
* @return {String}
|
|
* @api private
|
|
*/
|
|
|
|
function serialize(obj) {
|
|
if (!isObject(obj)) return obj;
|
|
var pairs = [];
|
|
for (var key in obj) {
|
|
if (null != obj[key]) {
|
|
pairs.push(encodeURIComponent(key)
|
|
+ '=' + encodeURIComponent(obj[key]));
|
|
}
|
|
}
|
|
return pairs.join('&');
|
|
}
|
|
|
|
/**
|
|
* Expose serialization method.
|
|
*/
|
|
|
|
request.serializeObject = serialize;
|
|
|
|
/**
|
|
* Parse the given x-www-form-urlencoded `str`.
|
|
*
|
|
* @param {String} str
|
|
* @return {Object}
|
|
* @api private
|
|
*/
|
|
|
|
function parseString(str) {
|
|
var obj = {};
|
|
var pairs = str.split('&');
|
|
var parts;
|
|
var pair;
|
|
|
|
for (var i = 0, len = pairs.length; i < len; ++i) {
|
|
pair = pairs[i];
|
|
parts = pair.split('=');
|
|
obj[decodeURIComponent(parts[0])] = decodeURIComponent(parts[1]);
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
/**
|
|
* Expose parser.
|
|
*/
|
|
|
|
request.parseString = parseString;
|
|
|
|
/**
|
|
* Default MIME type map.
|
|
*
|
|
* superagent.types.xml = 'application/xml';
|
|
*
|
|
*/
|
|
|
|
request.types = {
|
|
html: 'text/html',
|
|
json: 'application/json',
|
|
xml: 'application/xml',
|
|
urlencoded: 'application/x-www-form-urlencoded',
|
|
'form': 'application/x-www-form-urlencoded',
|
|
'form-data': 'application/x-www-form-urlencoded'
|
|
};
|
|
|
|
/**
|
|
* Default serialization map.
|
|
*
|
|
* superagent.serialize['application/xml'] = function(obj){
|
|
* return 'generated xml here';
|
|
* };
|
|
*
|
|
*/
|
|
|
|
request.serialize = {
|
|
'application/x-www-form-urlencoded': serialize,
|
|
'application/json': JSON.stringify
|
|
};
|
|
|
|
/**
|
|
* Default parsers.
|
|
*
|
|
* superagent.parse['application/xml'] = function(str){
|
|
* return { object parsed from str };
|
|
* };
|
|
*
|
|
*/
|
|
|
|
request.parse = {
|
|
'application/x-www-form-urlencoded': parseString,
|
|
'application/json': JSON.parse
|
|
};
|
|
|
|
/**
|
|
* Parse the given header `str` into
|
|
* an object containing the mapped fields.
|
|
*
|
|
* @param {String} str
|
|
* @return {Object}
|
|
* @api private
|
|
*/
|
|
|
|
function parseHeader(str) {
|
|
var lines = str.split(/\r?\n/);
|
|
var fields = {};
|
|
var index;
|
|
var line;
|
|
var field;
|
|
var val;
|
|
|
|
lines.pop(); // trailing CRLF
|
|
|
|
for (var i = 0, len = lines.length; i < len; ++i) {
|
|
line = lines[i];
|
|
index = line.indexOf(':');
|
|
field = line.slice(0, index).toLowerCase();
|
|
val = trim(line.slice(index + 1));
|
|
fields[field] = val;
|
|
}
|
|
|
|
return fields;
|
|
}
|
|
|
|
/**
|
|
* Return the mime type for the given `str`.
|
|
*
|
|
* @param {String} str
|
|
* @return {String}
|
|
* @api private
|
|
*/
|
|
|
|
function type(str){
|
|
return str.split(/ *; */).shift();
|
|
};
|
|
|
|
/**
|
|
* Return header field parameters.
|
|
*
|
|
* @param {String} str
|
|
* @return {Object}
|
|
* @api private
|
|
*/
|
|
|
|
function params(str){
|
|
return reduce(str.split(/ *; */), function(obj, str){
|
|
var parts = str.split(/ *= */)
|
|
, key = parts.shift()
|
|
, val = parts.shift();
|
|
|
|
if (key && val) obj[key] = val;
|
|
return obj;
|
|
}, {});
|
|
};
|
|
|
|
/**
|
|
* Initialize a new `Response` with the given `xhr`.
|
|
*
|
|
* - set flags (.ok, .error, etc)
|
|
* - parse header
|
|
*
|
|
* Examples:
|
|
*
|
|
* Aliasing `superagent` as `request` is nice:
|
|
*
|
|
* request = superagent;
|
|
*
|
|
* We can use the promise-like API, or pass callbacks:
|
|
*
|
|
* request.get('/').end(function(res){});
|
|
* request.get('/', function(res){});
|
|
*
|
|
* Sending data can be chained:
|
|
*
|
|
* request
|
|
* .post('/user')
|
|
* .send({ name: 'tj' })
|
|
* .end(function(res){});
|
|
*
|
|
* Or passed to `.send()`:
|
|
*
|
|
* request
|
|
* .post('/user')
|
|
* .send({ name: 'tj' }, function(res){});
|
|
*
|
|
* Or passed to `.post()`:
|
|
*
|
|
* request
|
|
* .post('/user', { name: 'tj' })
|
|
* .end(function(res){});
|
|
*
|
|
* Or further reduced to a single call for simple cases:
|
|
*
|
|
* request
|
|
* .post('/user', { name: 'tj' }, function(res){});
|
|
*
|
|
* @param {XMLHTTPRequest} xhr
|
|
* @param {Object} options
|
|
* @api private
|
|
*/
|
|
|
|
function Response(req, options) {
|
|
options = options || {};
|
|
this.req = req;
|
|
this.xhr = this.req.xhr;
|
|
this.text = this.xhr.responseText;
|
|
this.setStatusProperties(typeof this.xhr.status !== 'undefined' ? this.xhr.status : 0);
|
|
if (typeof this.xhr.getAllResponseHeaders !== 'undefined' &&
|
|
typeof this.xhr.getResponseHeader !== 'undefined') {
|
|
this.header = this.headers = parseHeader(this.xhr.getAllResponseHeaders());
|
|
// getAllResponseHeaders sometimes falsely returns "" for CORS requests, but
|
|
// getResponseHeader still works. so we get content-type even if getting
|
|
// other headers fails.
|
|
this.header['content-type'] = this.xhr.getResponseHeader('content-type');
|
|
this.setHeaderProperties(this.header);
|
|
} else if (typeof this.xhr.contentType !== 'undefined') {
|
|
this.header = this.headers = {};
|
|
this.header['content-type'] = this.xhr.contentType;
|
|
this.setHeaderProperties(this.header);
|
|
}
|
|
this.body = this.req.method != 'HEAD'
|
|
? this.parseBody(this.text)
|
|
: null;
|
|
}
|
|
|
|
/**
|
|
* Get case-insensitive `field` value.
|
|
*
|
|
* @param {String} field
|
|
* @return {String}
|
|
* @api public
|
|
*/
|
|
|
|
Response.prototype.get = function(field){
|
|
return this.header[field.toLowerCase()];
|
|
};
|
|
|
|
/**
|
|
* Set header related properties:
|
|
*
|
|
* - `.type` the content type without params
|
|
*
|
|
* A response of "Content-Type: text/plain; charset=utf-8"
|
|
* will provide you with a `.type` of "text/plain".
|
|
*
|
|
* @param {Object} header
|
|
* @api private
|
|
*/
|
|
|
|
Response.prototype.setHeaderProperties = function(header){
|
|
// content-type
|
|
var ct = this.header['content-type'] || '';
|
|
this.type = type(ct);
|
|
|
|
// params
|
|
var obj = params(ct);
|
|
for (var key in obj) this[key] = obj[key];
|
|
};
|
|
|
|
/**
|
|
* Parse the given body `str`.
|
|
*
|
|
* Used for auto-parsing of bodies. Parsers
|
|
* are defined on the `superagent.parse` object.
|
|
*
|
|
* @param {String} str
|
|
* @return {Mixed}
|
|
* @api private
|
|
*/
|
|
|
|
Response.prototype.parseBody = function(str){
|
|
var parse = request.parse[this.type];
|
|
return parse && str && str.length
|
|
? parse(str)
|
|
: null;
|
|
};
|
|
|
|
/**
|
|
* Set flags such as `.ok` based on `status`.
|
|
*
|
|
* For example a 2xx response will give you a `.ok` of __true__
|
|
* whereas 5xx will be __false__ and `.error` will be __true__. The
|
|
* `.clientError` and `.serverError` are also available to be more
|
|
* specific, and `.statusType` is the class of error ranging from 1..5
|
|
* sometimes useful for mapping respond colors etc.
|
|
*
|
|
* "sugar" properties are also defined for common cases. Currently providing:
|
|
*
|
|
* - .noContent
|
|
* - .badRequest
|
|
* - .unauthorized
|
|
* - .notAcceptable
|
|
* - .notFound
|
|
*
|
|
* @param {Number} status
|
|
* @api private
|
|
*/
|
|
|
|
Response.prototype.setStatusProperties = function(status){
|
|
var type = status / 100 | 0;
|
|
|
|
// status / class
|
|
this.status = status;
|
|
this.statusType = type;
|
|
|
|
// basics
|
|
this.info = 1 == type;
|
|
this.ok = 2 == type;
|
|
this.clientError = 4 == type;
|
|
this.serverError = 5 == type;
|
|
this.error = (4 == type || 5 == type)
|
|
? this.toError()
|
|
: false;
|
|
|
|
// sugar
|
|
this.accepted = 202 == status;
|
|
this.noContent = 204 == status || 1223 == status;
|
|
this.badRequest = 400 == status;
|
|
this.unauthorized = 401 == status;
|
|
this.notAcceptable = 406 == status;
|
|
this.notFound = 404 == status;
|
|
this.forbidden = 403 == status;
|
|
};
|
|
|
|
/**
|
|
* Return an `Error` representative of this response.
|
|
*
|
|
* @return {Error}
|
|
* @api public
|
|
*/
|
|
|
|
Response.prototype.toError = function(){
|
|
var req = this.req;
|
|
var method = req.method;
|
|
var url = req.url;
|
|
|
|
var msg = 'cannot ' + method + ' ' + url + ' (' + this.status + ')';
|
|
var err = new Error(msg);
|
|
err.status = this.status;
|
|
err.method = method;
|
|
err.url = url;
|
|
|
|
return err;
|
|
};
|
|
|
|
/**
|
|
* Expose `Response`.
|
|
*/
|
|
|
|
request.Response = Response;
|
|
|
|
/**
|
|
* Initialize a new `Request` with the given `method` and `url`.
|
|
*
|
|
* @param {String} method
|
|
* @param {String} url
|
|
* @api public
|
|
*/
|
|
|
|
function Request(method, url) {
|
|
var self = this;
|
|
Emitter.call(this);
|
|
this._query = this._query || [];
|
|
this.method = method;
|
|
this.url = url;
|
|
this.header = {};
|
|
this._header = {};
|
|
this.on('end', function(){
|
|
var res = new Response(self);
|
|
if ('HEAD' == method) res.text = null;
|
|
self.callback(null, res);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Mixin `Emitter`.
|
|
*/
|
|
|
|
Emitter(Request.prototype);
|
|
|
|
/**
|
|
* Allow for extension
|
|
*/
|
|
|
|
Request.prototype.use = function(fn) {
|
|
fn(this);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set timeout to `ms`.
|
|
*
|
|
* @param {Number} ms
|
|
* @return {Request} for chaining
|
|
* @api public
|
|
*/
|
|
|
|
Request.prototype.timeout = function(ms){
|
|
this._timeout = ms;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Clear previous timeout.
|
|
*
|
|
* @return {Request} for chaining
|
|
* @api public
|
|
*/
|
|
|
|
Request.prototype.clearTimeout = function(){
|
|
this._timeout = 0;
|
|
clearTimeout(this._timer);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Abort the request, and clear potential timeout.
|
|
*
|
|
* @return {Request}
|
|
* @api public
|
|
*/
|
|
|
|
Request.prototype.abort = function(){
|
|
if (this.aborted) return;
|
|
this.aborted = true;
|
|
this.xhr.abort();
|
|
this.clearTimeout();
|
|
this.emit('abort');
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Set header `field` to `val`, or multiple fields with one object.
|
|
*
|
|
* Examples:
|
|
*
|
|
* req.get('/')
|
|
* .set('Accept', 'application/json')
|
|
* .set('X-API-Key', 'foobar')
|
|
* .end(callback);
|
|
*
|
|
* req.get('/')
|
|
* .set({ Accept: 'application/json', 'X-API-Key': 'foobar' })
|
|
* .end(callback);
|
|
*
|
|
* @param {String|Object} field
|
|
* @param {String} val
|
|
* @return {Request} for chaining
|
|
* @api public
|
|
*/
|
|
|
|
Request.prototype.set = function(field, val){
|
|
if (isObject(field)) {
|
|
for (var key in field) {
|
|
this.set(key, field[key]);
|
|
}
|
|
return this;
|
|
}
|
|
this._header[field.toLowerCase()] = val;
|
|
this.header[field] = val;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Get case-insensitive header `field` value.
|
|
*
|
|
* @param {String} field
|
|
* @return {String}
|
|
* @api private
|
|
*/
|
|
|
|
Request.prototype.getHeader = function(field){
|
|
return this._header[field.toLowerCase()];
|
|
};
|
|
|
|
/**
|
|
* Set Content-Type to `type`, mapping values from `request.types`.
|
|
*
|
|
* Examples:
|
|
*
|
|
* superagent.types.xml = 'application/xml';
|
|
*
|
|
* request.post('/')
|
|
* .type('xml')
|
|
* .send(xmlstring)
|
|
* .end(callback);
|
|
*
|
|
* request.post('/')
|
|
* .type('application/xml')
|
|
* .send(xmlstring)
|
|
* .end(callback);
|
|
*
|
|
* @param {String} type
|
|
* @return {Request} for chaining
|
|
* @api public
|
|
*/
|
|
|
|
Request.prototype.type = function(type){
|
|
this.set('Content-Type', request.types[type] || type);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Set Accept to `type`, mapping values from `request.types`.
|
|
*
|
|
* Examples:
|
|
*
|
|
* superagent.types.json = 'application/json';
|
|
*
|
|
* request.get('/agent')
|
|
* .accept('json')
|
|
* .end(callback);
|
|
*
|
|
* request.get('/agent')
|
|
* .accept('application/json')
|
|
* .end(callback);
|
|
*
|
|
* @param {String} accept
|
|
* @return {Request} for chaining
|
|
* @api public
|
|
*/
|
|
|
|
Request.prototype.accept = function(type){
|
|
this.set('Accept', request.types[type] || type);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Set Authorization field value with `user` and `pass`.
|
|
*
|
|
* @param {String} user
|
|
* @param {String} pass
|
|
* @return {Request} for chaining
|
|
* @api public
|
|
*/
|
|
|
|
Request.prototype.auth = function(user, pass){
|
|
var str = btoa(user + ':' + pass);
|
|
this.set('Authorization', 'Basic ' + str);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Add query-string `val`.
|
|
*
|
|
* Examples:
|
|
*
|
|
* request.get('/shoes')
|
|
* .query('size=10')
|
|
* .query({ color: 'blue' })
|
|
*
|
|
* @param {Object|String} val
|
|
* @return {Request} for chaining
|
|
* @api public
|
|
*/
|
|
|
|
Request.prototype.query = function(val){
|
|
if ('string' != typeof val) val = serialize(val);
|
|
if (val) this._query.push(val);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Write the field `name` and `val` for "multipart/form-data"
|
|
* request bodies.
|
|
*
|
|
* ``` js
|
|
* request.post('/upload')
|
|
* .field('foo', 'bar')
|
|
* .end(callback);
|
|
* ```
|
|
*
|
|
* @param {String} name
|
|
* @param {String|Blob|File} val
|
|
* @return {Request} for chaining
|
|
* @api public
|
|
*/
|
|
|
|
Request.prototype.field = function(name, val){
|
|
if (!this._formData) this._formData = new FormData();
|
|
this._formData.append(name, val);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Queue the given `file` as an attachment to the specified `field`,
|
|
* with optional `filename`.
|
|
*
|
|
* ``` js
|
|
* request.post('/upload')
|
|
* .attach(new Blob(['<a id="a"><b id="b">hey!</b></a>'], { type: "text/html"}))
|
|
* .end(callback);
|
|
* ```
|
|
*
|
|
* @param {String} field
|
|
* @param {Blob|File} file
|
|
* @param {String} filename
|
|
* @return {Request} for chaining
|
|
* @api public
|
|
*/
|
|
|
|
Request.prototype.attach = function(field, file, filename){
|
|
if (!this._formData) this._formData = new FormData();
|
|
this._formData.append(field, file, filename);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Send `data`, defaulting the `.type()` to "json" when
|
|
* an object is given.
|
|
*
|
|
* Examples:
|
|
*
|
|
* // querystring
|
|
* request.get('/search')
|
|
* .end(callback)
|
|
*
|
|
* // multiple data "writes"
|
|
* request.get('/search')
|
|
* .send({ search: 'query' })
|
|
* .send({ range: '1..5' })
|
|
* .send({ order: 'desc' })
|
|
* .end(callback)
|
|
*
|
|
* // manual json
|
|
* request.post('/user')
|
|
* .type('json')
|
|
* .send('{"name":"tj"})
|
|
* .end(callback)
|
|
*
|
|
* // auto json
|
|
* request.post('/user')
|
|
* .send({ name: 'tj' })
|
|
* .end(callback)
|
|
*
|
|
* // manual x-www-form-urlencoded
|
|
* request.post('/user')
|
|
* .type('form')
|
|
* .send('name=tj')
|
|
* .end(callback)
|
|
*
|
|
* // auto x-www-form-urlencoded
|
|
* request.post('/user')
|
|
* .type('form')
|
|
* .send({ name: 'tj' })
|
|
* .end(callback)
|
|
*
|
|
* // defaults to x-www-form-urlencoded
|
|
* request.post('/user')
|
|
* .send('name=tobi')
|
|
* .send('species=ferret')
|
|
* .end(callback)
|
|
*
|
|
* @param {String|Object} data
|
|
* @return {Request} for chaining
|
|
* @api public
|
|
*/
|
|
|
|
Request.prototype.send = function(data){
|
|
var obj = isObject(data);
|
|
var type = this.getHeader('Content-Type');
|
|
|
|
// merge
|
|
if (obj && isObject(this._data)) {
|
|
for (var key in data) {
|
|
this._data[key] = data[key];
|
|
}
|
|
} else if ('string' == typeof data) {
|
|
if (!type) this.type('form');
|
|
type = this.getHeader('Content-Type');
|
|
if ('application/x-www-form-urlencoded' == type) {
|
|
this._data = this._data
|
|
? this._data + '&' + data
|
|
: data;
|
|
} else {
|
|
this._data = (this._data || '') + data;
|
|
}
|
|
} else {
|
|
this._data = data;
|
|
}
|
|
|
|
if (!obj) return this;
|
|
if (!type) this.type('json');
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Invoke the callback with `err` and `res`
|
|
* and handle arity check.
|
|
*
|
|
* @param {Error} err
|
|
* @param {Response} res
|
|
* @api private
|
|
*/
|
|
|
|
Request.prototype.callback = function(err, res){
|
|
var fn = this._callback;
|
|
if (2 == fn.length) return fn(err, res);
|
|
if (err) return this.emit('error', err);
|
|
fn(res);
|
|
};
|
|
|
|
/**
|
|
* Invoke callback with x-domain error.
|
|
*
|
|
* @api private
|
|
*/
|
|
|
|
Request.prototype.crossDomainError = function(){
|
|
var err = new Error('Origin is not allowed by Access-Control-Allow-Origin');
|
|
err.crossDomain = true;
|
|
this.callback(err);
|
|
};
|
|
|
|
/**
|
|
* Invoke callback with timeout error.
|
|
*
|
|
* @api private
|
|
*/
|
|
|
|
Request.prototype.timeoutError = function(){
|
|
var timeout = this._timeout;
|
|
var err = new Error('timeout of ' + timeout + 'ms exceeded');
|
|
err.timeout = timeout;
|
|
this.callback(err);
|
|
};
|
|
|
|
/**
|
|
* Enable transmission of cookies with x-domain requests.
|
|
*
|
|
* Note that for this to work the origin must not be
|
|
* using "Access-Control-Allow-Origin" with a wildcard,
|
|
* and also must set "Access-Control-Allow-Credentials"
|
|
* to "true".
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
Request.prototype.withCredentials = function(){
|
|
this._withCredentials = true;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Initiate request, invoking callback `fn(res)`
|
|
* with an instanceof `Response`.
|
|
*
|
|
* @param {Function} fn
|
|
* @return {Request} for chaining
|
|
* @api public
|
|
*/
|
|
|
|
Request.prototype.end = function(fn){
|
|
var self = this;
|
|
|
|
var isXDomainRequest = false;
|
|
|
|
if (typeof root.location !== 'undefined') {
|
|
var hostnameMatch = this.url.match(/http[s]?:\/\/([^\/]*)/);
|
|
|
|
if (hostnameMatch && hostnameMatch[1] !== root.location.hostname) {
|
|
isXDomainRequest = true;
|
|
}
|
|
}
|
|
|
|
var xhr = this.xhr = getXHR(isXDomainRequest);
|
|
var query = this._query.join('&');
|
|
var timeout = this._timeout;
|
|
var data = this._formData || this._data;
|
|
|
|
// store callback
|
|
this._callback = fn || noop;
|
|
|
|
// state change
|
|
if (typeof xhr.onreadystatechange !== 'undefined') {
|
|
xhr.onreadystatechange = function(){
|
|
if (4 != xhr.readyState) return;
|
|
if (0 == xhr.status) {
|
|
if (self.aborted) return self.timeoutError();
|
|
return self.crossDomainError();
|
|
}
|
|
self.emit('end');
|
|
};
|
|
} else {
|
|
xhr.onload = function () {
|
|
if (self.aborted) return self.timeoutError();
|
|
self.emit('end');
|
|
}
|
|
|
|
xhr.onerror = function () {
|
|
self.emit('end');
|
|
}
|
|
|
|
xhr.ontimeout = function () {
|
|
return self.timeoutError();
|
|
}
|
|
}
|
|
|
|
// progress
|
|
if (xhr.upload) {
|
|
xhr.upload.onprogress = function(e){
|
|
e.percent = e.loaded / e.total * 100;
|
|
self.emit('progress', e);
|
|
};
|
|
}
|
|
|
|
// timeout
|
|
if (timeout && !this._timer) {
|
|
this._timer = setTimeout(function(){
|
|
self.abort();
|
|
}, timeout);
|
|
}
|
|
|
|
// querystring
|
|
if (query) {
|
|
query = request.serializeObject(query);
|
|
this.url += ~this.url.indexOf('?')
|
|
? '&' + query
|
|
: '?' + query;
|
|
}
|
|
|
|
// initiate request
|
|
xhr.open(this.method, this.url, true);
|
|
|
|
// CORS
|
|
if (this._withCredentials) xhr.withCredentials = true;
|
|
|
|
// body
|
|
if ('GET' != this.method && 'HEAD' != this.method && 'string' != typeof data && !isHost(data)) {
|
|
// serialize stuff
|
|
var serialize = request.serialize[this.getHeader('Content-Type')];
|
|
if (serialize) data = serialize(data);
|
|
}
|
|
|
|
// set header fields
|
|
for (var field in this.header) {
|
|
if (null == this.header[field]) continue;
|
|
if (typeof xhr.setRequestHeader !== 'undefined') {
|
|
xhr.setRequestHeader(field, this.header[field]);
|
|
}
|
|
}
|
|
|
|
// send stuff
|
|
this.emit('request', this);
|
|
xhr.send(data);
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Expose `Request`.
|
|
*/
|
|
|
|
request.Request = Request;
|
|
|
|
/**
|
|
* Issue a request:
|
|
*
|
|
* Examples:
|
|
*
|
|
* request('GET', '/users').end(callback)
|
|
* request('/users').end(callback)
|
|
* request('/users', callback)
|
|
*
|
|
* @param {String} method
|
|
* @param {String|Function} url or callback
|
|
* @return {Request}
|
|
* @api public
|
|
*/
|
|
|
|
function request(method, url) {
|
|
// callback
|
|
if ('function' == typeof url) {
|
|
return new Request('GET', method).end(url);
|
|
}
|
|
|
|
// url first
|
|
if (1 == arguments.length) {
|
|
return new Request('GET', method);
|
|
}
|
|
|
|
return new Request(method, url);
|
|
}
|
|
|
|
/**
|
|
* GET `url` with optional callback `fn(res)`.
|
|
*
|
|
* @param {String} url
|
|
* @param {Mixed|Function} data or fn
|
|
* @param {Function} fn
|
|
* @return {Request}
|
|
* @api public
|
|
*/
|
|
|
|
request.get = function(url, data, fn){
|
|
var req = request('GET', url);
|
|
if ('function' == typeof data) fn = data, data = null;
|
|
if (data) req.query(data);
|
|
if (fn) req.end(fn);
|
|
return req;
|
|
};
|
|
|
|
/**
|
|
* HEAD `url` with optional callback `fn(res)`.
|
|
*
|
|
* @param {String} url
|
|
* @param {Mixed|Function} data or fn
|
|
* @param {Function} fn
|
|
* @return {Request}
|
|
* @api public
|
|
*/
|
|
|
|
request.head = function(url, data, fn){
|
|
var req = request('HEAD', url);
|
|
if ('function' == typeof data) fn = data, data = null;
|
|
if (data) req.send(data);
|
|
if (fn) req.end(fn);
|
|
return req;
|
|
};
|
|
|
|
/**
|
|
* DELETE `url` with optional callback `fn(res)`.
|
|
*
|
|
* @param {String} url
|
|
* @param {Function} fn
|
|
* @return {Request}
|
|
* @api public
|
|
*/
|
|
|
|
request.del = function(url, fn){
|
|
var req = request('DELETE', url);
|
|
if (fn) req.end(fn);
|
|
return req;
|
|
};
|
|
|
|
/**
|
|
* PATCH `url` with optional `data` and callback `fn(res)`.
|
|
*
|
|
* @param {String} url
|
|
* @param {Mixed} data
|
|
* @param {Function} fn
|
|
* @return {Request}
|
|
* @api public
|
|
*/
|
|
|
|
request.patch = function(url, data, fn){
|
|
var req = request('PATCH', url);
|
|
if ('function' == typeof data) fn = data, data = null;
|
|
if (data) req.send(data);
|
|
if (fn) req.end(fn);
|
|
return req;
|
|
};
|
|
|
|
/**
|
|
* POST `url` with optional `data` and callback `fn(res)`.
|
|
*
|
|
* @param {String} url
|
|
* @param {Mixed} data
|
|
* @param {Function} fn
|
|
* @return {Request}
|
|
* @api public
|
|
*/
|
|
|
|
request.post = function(url, data, fn){
|
|
var req = request('POST', url);
|
|
if ('function' == typeof data) fn = data, data = null;
|
|
if (data) req.send(data);
|
|
if (fn) req.end(fn);
|
|
return req;
|
|
};
|
|
|
|
/**
|
|
* PUT `url` with optional `data` and callback `fn(res)`.
|
|
*
|
|
* @param {String} url
|
|
* @param {Mixed|Function} data or fn
|
|
* @param {Function} fn
|
|
* @return {Request}
|
|
* @api public
|
|
*/
|
|
|
|
request.put = function(url, data, fn){
|
|
var req = request('PUT', url);
|
|
if ('function' == typeof data) fn = data, data = null;
|
|
if (data) req.send(data);
|
|
if (fn) req.end(fn);
|
|
return req;
|
|
};
|
|
|
|
/**
|
|
* Expose `request`.
|
|
*/
|
|
|
|
module.exports = request;
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
require.alias("component-emitter/index.js", "superagent/deps/emitter/index.js");
|
|
require.alias("component-emitter/index.js", "emitter/index.js");
|
|
|
|
require.alias("component-reduce/index.js", "superagent/deps/reduce/index.js");
|
|
require.alias("component-reduce/index.js", "reduce/index.js");
|
|
|
|
require.alias("superagent/lib/client.js", "superagent/index.js");if (typeof exports == "object") {
|
|
module.exports = require("superagent");
|
|
} else if (typeof define == "function" && define.amd) {
|
|
define([], function(){ return require("superagent"); });
|
|
} else {
|
|
this["superagent"] = require("superagent");
|
|
}})(); |