341 lines
13 KiB
JavaScript
341 lines
13 KiB
JavaScript
var utils = require('./utils/utils');
|
||
var isBrowser = typeof document !== "undefined";
|
||
|
||
class Fly {
|
||
constructor(engine) {
|
||
this.engine = engine || XMLHttpRequest;
|
||
|
||
this.default = this //For typeScript
|
||
|
||
/**
|
||
* Add lock/unlock API for interceptor.
|
||
*
|
||
* Once an request/response interceptor is locked, the incoming request/response
|
||
* will be added to a queue before they enter the interceptor, they will not be
|
||
* continued until the interceptor is unlocked.
|
||
*
|
||
* @param [interceptor] either is interceptors.request or interceptors.response
|
||
*/
|
||
function wrap(interceptor) {
|
||
var resolve;
|
||
var reject;
|
||
|
||
function _clear() {
|
||
interceptor.p = resolve = reject = null;
|
||
}
|
||
|
||
utils.merge(interceptor, {
|
||
lock() {
|
||
if (!resolve) {
|
||
interceptor.p = new Promise((_resolve, _reject) => {
|
||
resolve = _resolve
|
||
reject = _reject;
|
||
})
|
||
}
|
||
},
|
||
unlock() {
|
||
if (resolve) {
|
||
resolve()
|
||
_clear();
|
||
}
|
||
},
|
||
clear() {
|
||
if (reject) {
|
||
reject("cancel");
|
||
_clear();
|
||
}
|
||
}
|
||
})
|
||
}
|
||
|
||
var interceptors = this.interceptors = {
|
||
response: {
|
||
use(handler, onerror) {
|
||
this.handler = handler;
|
||
this.onerror = onerror;
|
||
}
|
||
},
|
||
request: {
|
||
use(handler) {
|
||
this.handler = handler;
|
||
}
|
||
}
|
||
}
|
||
|
||
var irq = interceptors.request;
|
||
var irp = interceptors.response;
|
||
wrap(irp);
|
||
wrap(irq);
|
||
|
||
this.config = {
|
||
method: "GET",
|
||
baseURL: "",
|
||
headers: {},
|
||
timeout: 0,
|
||
parseJson: true, // Convert response data to JSON object automatically.
|
||
withCredentials: false
|
||
}
|
||
}
|
||
|
||
request(url, data, options) {
|
||
var engine = new this.engine;
|
||
var contentType = "Content-Type";
|
||
var interceptors = this.interceptors;
|
||
var requestInterceptor = interceptors.request;
|
||
var responseInterceptor = interceptors.response;
|
||
var requestInterceptorHandler = requestInterceptor.handler;
|
||
var promise = new Promise((resolve, reject) => {
|
||
if (utils.isObject(url)) {
|
||
options = url;
|
||
url = options.url;
|
||
}
|
||
options = options || {};
|
||
options.headers = options.headers || {};
|
||
|
||
function isPromise(p) {
|
||
// some polyfill implementation of Promise may be not standard,
|
||
// so, we test by duck-typing
|
||
return p && p.then && p.catch
|
||
}
|
||
|
||
/**
|
||
* If the request/response interceptor has been locked，
|
||
* the new request/response will enter a queue. otherwise, it will be performed directly.
|
||
* @param [promise] if the promise exist, means the interceptor is locked.
|
||
* @param [callback]
|
||
*/
|
||
function enqueueIfLocked(promise, callback) {
|
||
if (promise) {
|
||
promise.then(() => {
|
||
callback()
|
||
})
|
||
} else {
|
||
callback()
|
||
}
|
||
}
|
||
|
||
// make the http request
|
||
function makeRequest(options) {
|
||
data = options.body;
|
||
// Normalize the request url
|
||
url = utils.trim(options.url);
|
||
var baseUrl = utils.trim(options.baseURL || "");
|
||
if (!url && isBrowser && !baseUrl) url = location.href;
|
||
if (url.indexOf("http") !== 0) {
|
||
var isAbsolute = url[0] === "/";
|
||
if (!baseUrl && isBrowser) {
|
||
var arr = location.pathname.split("/");
|
||
arr.pop();
|
||
baseUrl = location.protocol + "//" + location.host + (isAbsolute ? "" : arr.join("/"))
|
||
}
|
||
if (baseUrl[baseUrl.length - 1] !== "/") {
|
||
baseUrl += "/"
|
||
}
|
||
url = baseUrl + (isAbsolute ? url.substr(1) : url)
|
||
if (isBrowser) {
|
||
|
||
// Normalize the url which contains the ".." or ".", such as
|
||
// "http://xx.com/aa/bb/../../xx" to "http://xx.com/xx" .
|
||
var t = document.createElement("a");
|
||
t.href = url;
|
||
url = t.href;
|
||
}
|
||
}
|
||
|
||
var responseType = utils.trim(options.responseType || "")
|
||
engine.withCredentials = !!options.withCredentials;
|
||
var isGet = options.method === "GET";
|
||
if (isGet) {
|
||
if (data) {
|
||
if (utils.type(data) !== "string") {
|
||
data = utils.formatParams(data);
|
||
}
|
||
url += (url.indexOf("?") === -1 ? "?" : "&") + data;
|
||
}
|
||
}
|
||
engine.open(options.method, url);
|
||
|
||
// try catch for ie >=9
|
||
try {
|
||
engine.timeout = options.timeout || 0;
|
||
if (responseType !== "stream") {
|
||
engine.responseType = responseType
|
||
}
|
||
} catch (e) {
|
||
}
|
||
|
||
var customContentType = options.headers[contentType] || options.headers[contentType.toLowerCase()];
|
||
|
||
// default content type
|
||
var _contentType = "application/x-www-form-urlencoded";
|
||
// If the request data is json object, transforming it to json string,
|
||
// and set request content-type to "json". In browser, the data will
|
||
// be sent as RequestBody instead of FormData
|
||
if (utils.trim((customContentType || "").toLowerCase()) === _contentType) {
|
||
data = utils.formatParams(data);
|
||
} else if (!utils.isFormData(data) && ["object", "array"].indexOf(utils.type(data)) !== -1) {
|
||
_contentType = 'application/json;charset=utf-8'
|
||
data = JSON.stringify(data);
|
||
}
|
||
//If user doesn't set content-type, set default.
|
||
if (!customContentType) {
|
||
options.headers[contentType] = _contentType;
|
||
}
|
||
|
||
for (var k in options.headers) {
|
||
if (k === contentType && utils.isFormData(data)) {
|
||
// Delete the content-type, Let the browser set it
|
||
delete options.headers[k];
|
||
} else {
|
||
try {
|
||
// In browser environment, some header fields are readonly,
|
||
// write will cause the exception .
|
||
engine.setRequestHeader(k, options.headers[k])
|
||
} catch (e) {
|
||
}
|
||
}
|
||
}
|
||
|
||
function onresult(handler, data, type) {
|
||
enqueueIfLocked(responseInterceptor.p, function () {
|
||
if (handler) {
|
||
//如果失败，添加请求信息
|
||
if (type) {
|
||
data.request = options;
|
||
}
|
||
var ret = handler.call(responseInterceptor, data, Promise)
|
||
data = ret === undefined ? data : ret;
|
||
}
|
||
if (!isPromise(data)) {
|
||
data = Promise[type === 0 ? "resolve" : "reject"](data)
|
||
}
|
||
data.then(d => {
|
||
resolve(d)
|
||
}).catch((e) => {
|
||
reject(e)
|
||
})
|
||
})
|
||
}
|
||
|
||
|
||
function onerror(e) {
|
||
e.engine = engine;
|
||
onresult(responseInterceptor.onerror, e, -1)
|
||
}
|
||
|
||
function Err(msg, status) {
|
||
this.message = msg
|
||
this.status = status;
|
||
}
|
||
|
||
engine.onload = () => {
|
||
// The xhr of IE9 has not response filed
|
||
var response = engine.response || engine.responseText;
|
||
if (response && options.parseJson && (engine.getResponseHeader(contentType) || "").indexOf("json") !== -1
|
||
// Some third engine implementation may transform the response text to json object automatically,
|
||
// so we should test the type of response before transforming it
|
||
&& !utils.isObject(response)) {
|
||
response = JSON.parse(response);
|
||
}
|
||
var headers = {};
|
||
var items = (engine.getAllResponseHeaders() || "").split("\r\n");
|
||
items.pop();
|
||
items.forEach((e) => {
|
||
var key = e.split(":")[0]
|
||
headers[key] = engine.getResponseHeader(key)
|
||
})
|
||
var status = engine.status
|
||
var statusText = engine.statusText
|
||
var data = {data: response, headers, status, statusText};
|
||
// The _response filed of engine is set in adapter which be called in engine-wrapper.js
|
||
utils.merge(data, engine._response)
|
||
if ((status >= 200 && status < 300) || status === 304) {
|
||
data.engine = engine;
|
||
data.request = options;
|
||
onresult(responseInterceptor.handler, data, 0)
|
||
} else {
|
||
var e = new Err(statusText, status);
|
||
e.response = data
|
||
onerror(e)
|
||
}
|
||
}
|
||
|
||
engine.onerror = (e) => {
|
||
onerror(new Err(e.msg || "Network Error", 0))
|
||
}
|
||
|
||
engine.ontimeout = () => {
|
||
onerror(new Err(`timeout [ ${engine.timeout}ms ]`, 1))
|
||
}
|
||
engine._options = options;
|
||
setTimeout(() => {
|
||
engine.send(isGet ? null : data)
|
||
}, 0)
|
||
}
|
||
|
||
enqueueIfLocked(requestInterceptor.p, () => {
|
||
utils.merge(options, this.config)
|
||
var headers = options.headers;
|
||
headers[contentType] = headers[contentType] || headers[contentTypeLowerCase] || "";
|
||
delete headers[contentTypeLowerCase]
|
||
options.body = data || options.body;
|
||
url = utils.trim(url || "");
|
||
options.method = options.method.toUpperCase();
|
||
options.url = url;
|
||
var ret = options;
|
||
if (requestInterceptorHandler) {
|
||
ret = requestInterceptorHandler.call(requestInterceptor, options, Promise) || options;
|
||
}
|
||
if (!isPromise(ret)) {
|
||
ret = Promise.resolve(ret)
|
||
}
|
||
ret.then((d) => {
|
||
//if options continue
|
||
if (d === options) {
|
||
makeRequest(d)
|
||
} else {
|
||
resolve(d)
|
||
}
|
||
}, (err) => {
|
||
reject(err)
|
||
})
|
||
})
|
||
})
|
||
promise.engine = engine;
|
||
return promise;
|
||
}
|
||
|
||
all(promises) {
|
||
return Promise.all(promises)
|
||
}
|
||
|
||
spread(callback) {
|
||
return function (arr) {
|
||
return callback.apply(null, arr);
|
||
}
|
||
}
|
||
}
|
||
|
||
//For typeScript
|
||
Fly.default = Fly;
|
||
|
||
["get", "post", "put", "patch", "head", "delete"].forEach(e => {
|
||
Fly.prototype[e] = function (url, data, option) {
|
||
return this.request(url, data, utils.merge({method: e}, option))
|
||
}
|
||
})
|
||
["lock", "unlock", "clear"].forEach(e => {
|
||
Fly.prototype[e] = function () {
|
||
this.interceptors.request[e]();
|
||
}
|
||
})
|
||
// Learn more about keep-loader: https://github.com/wendux/keep-loader
|
||
KEEP("cdn||cdn-min", () => {
|
||
// This code block will be removed besides the "CDN" and "cdn-min" build environment
|
||
window.fly = new Fly;
|
||
window.Fly = Fly;
|
||
})
|
||
module.exports = Fly;
|
||
|
||
|