import { root } from '../../util/root';
|
import { Observable } from '../../Observable';
|
import { Subscriber } from '../../Subscriber';
|
import { TeardownLogic } from '../../types';
|
import { map } from '../../operators/map';
|
|
export interface AjaxRequest {
|
url?: string;
|
body?: any;
|
user?: string;
|
async?: boolean;
|
method?: string;
|
headers?: Object;
|
timeout?: number;
|
password?: string;
|
hasContent?: boolean;
|
crossDomain?: boolean;
|
withCredentials?: boolean;
|
createXHR?: () => XMLHttpRequest;
|
progressSubscriber?: Subscriber<any>;
|
responseType?: string;
|
}
|
|
function getCORSRequest(): XMLHttpRequest {
|
if (root.XMLHttpRequest) {
|
return new root.XMLHttpRequest();
|
} else if (!!root.XDomainRequest) {
|
return new root.XDomainRequest();
|
} else {
|
throw new Error('CORS is not supported by your browser');
|
}
|
}
|
|
function getXMLHttpRequest(): XMLHttpRequest {
|
if (root.XMLHttpRequest) {
|
return new root.XMLHttpRequest();
|
} else {
|
let progId: string;
|
try {
|
const progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'];
|
for (let i = 0; i < 3; i++) {
|
try {
|
progId = progIds[i];
|
if (new root.ActiveXObject(progId)) {
|
break;
|
}
|
} catch (e) {
|
//suppress exceptions
|
}
|
}
|
return new root.ActiveXObject(progId);
|
} catch (e) {
|
throw new Error('XMLHttpRequest is not supported by your browser');
|
}
|
}
|
}
|
|
export interface AjaxCreationMethod {
|
(urlOrRequest: string | AjaxRequest): Observable<AjaxResponse>;
|
get(url: string, headers?: Object): Observable<AjaxResponse>;
|
post(url: string, body?: any, headers?: Object): Observable<AjaxResponse>;
|
put(url: string, body?: any, headers?: Object): Observable<AjaxResponse>;
|
patch(url: string, body?: any, headers?: Object): Observable<AjaxResponse>;
|
delete(url: string, headers?: Object): Observable<AjaxResponse>;
|
getJSON<T>(url: string, headers?: Object): Observable<T>;
|
}
|
|
export function ajaxGet(url: string, headers: Object = null) {
|
return new AjaxObservable<AjaxResponse>({ method: 'GET', url, headers });
|
}
|
|
export function ajaxPost(url: string, body?: any, headers?: Object): Observable<AjaxResponse> {
|
return new AjaxObservable<AjaxResponse>({ method: 'POST', url, body, headers });
|
}
|
|
export function ajaxDelete(url: string, headers?: Object): Observable<AjaxResponse> {
|
return new AjaxObservable<AjaxResponse>({ method: 'DELETE', url, headers });
|
}
|
|
export function ajaxPut(url: string, body?: any, headers?: Object): Observable<AjaxResponse> {
|
return new AjaxObservable<AjaxResponse>({ method: 'PUT', url, body, headers });
|
}
|
|
export function ajaxPatch(url: string, body?: any, headers?: Object): Observable<AjaxResponse> {
|
return new AjaxObservable<AjaxResponse>({ method: 'PATCH', url, body, headers });
|
}
|
|
const mapResponse = map((x: AjaxResponse, index: number) => x.response);
|
|
export function ajaxGetJSON<T>(url: string, headers?: Object): Observable<T> {
|
return mapResponse(
|
new AjaxObservable<AjaxResponse>({
|
method: 'GET',
|
url,
|
responseType: 'json',
|
headers
|
})
|
);
|
}
|
|
/**
|
* We need this JSDoc comment for affecting ESDoc.
|
* @extends {Ignored}
|
* @hide true
|
*/
|
export class AjaxObservable<T> extends Observable<T> {
|
/**
|
* Creates an observable for an Ajax request with either a request object with
|
* url, headers, etc or a string for a URL.
|
*
|
* ## Example
|
* ```ts
|
* import { ajax } from 'rxjs/ajax';
|
*
|
* const source1 = ajax('/products');
|
* const source2 = ajax({ url: 'products', method: 'GET' });
|
* ```
|
*
|
* @param {string|Object} request Can be one of the following:
|
* A string of the URL to make the Ajax call.
|
* An object with the following properties
|
* - url: URL of the request
|
* - body: The body of the request
|
* - method: Method of the request, such as GET, POST, PUT, PATCH, DELETE
|
* - async: Whether the request is async
|
* - headers: Optional headers
|
* - crossDomain: true if a cross domain request, else false
|
* - createXHR: a function to override if you need to use an alternate
|
* XMLHttpRequest implementation.
|
* - resultSelector: a function to use to alter the output value type of
|
* the Observable. Gets {@link AjaxResponse} as an argument.
|
* @return {Observable} An observable sequence containing the XMLHttpRequest.
|
* @static true
|
* @name ajax
|
* @owner Observable
|
* @nocollapse
|
*/
|
static create: AjaxCreationMethod = (() => {
|
const create: any = (urlOrRequest: string | AjaxRequest) => {
|
return new AjaxObservable(urlOrRequest);
|
};
|
|
create.get = ajaxGet;
|
create.post = ajaxPost;
|
create.delete = ajaxDelete;
|
create.put = ajaxPut;
|
create.patch = ajaxPatch;
|
create.getJSON = ajaxGetJSON;
|
|
return <AjaxCreationMethod>create;
|
})();
|
|
private request: AjaxRequest;
|
|
constructor(urlOrRequest: string | AjaxRequest) {
|
super();
|
|
const request: AjaxRequest = {
|
async: true,
|
createXHR: function(this: AjaxRequest) {
|
return this.crossDomain ? getCORSRequest() : getXMLHttpRequest();
|
},
|
crossDomain: true,
|
withCredentials: false,
|
headers: {},
|
method: 'GET',
|
responseType: 'json',
|
timeout: 0
|
};
|
|
if (typeof urlOrRequest === 'string') {
|
request.url = urlOrRequest;
|
} else {
|
for (const prop in urlOrRequest) {
|
if (urlOrRequest.hasOwnProperty(prop)) {
|
request[prop] = urlOrRequest[prop];
|
}
|
}
|
}
|
|
this.request = request;
|
}
|
|
/** @deprecated This is an internal implementation detail, do not use. */
|
_subscribe(subscriber: Subscriber<T>): TeardownLogic {
|
return new AjaxSubscriber(subscriber, this.request);
|
}
|
}
|
|
/**
|
* We need this JSDoc comment for affecting ESDoc.
|
* @ignore
|
* @extends {Ignored}
|
*/
|
export class AjaxSubscriber<T> extends Subscriber<Event> {
|
private xhr: XMLHttpRequest;
|
private done: boolean = false;
|
|
constructor(destination: Subscriber<T>, public request: AjaxRequest) {
|
super(destination);
|
|
const headers = request.headers = request.headers || {};
|
|
// force CORS if requested
|
if (!request.crossDomain && !this.getHeader(headers, 'X-Requested-With')) {
|
headers['X-Requested-With'] = 'XMLHttpRequest';
|
}
|
|
// ensure content type is set
|
let contentTypeHeader = this.getHeader(headers, 'Content-Type');
|
if (!contentTypeHeader && !(root.FormData && request.body instanceof root.FormData) && typeof request.body !== 'undefined') {
|
headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8';
|
}
|
|
// properly serialize body
|
request.body = this.serializeBody(request.body, this.getHeader(request.headers, 'Content-Type'));
|
|
this.send();
|
}
|
|
next(e: Event): void {
|
this.done = true;
|
const { xhr, request, destination } = this;
|
let result;
|
try {
|
result = new AjaxResponse(e, xhr, request);
|
} catch (err) {
|
return destination.error(err);
|
}
|
destination.next(result);
|
}
|
|
private send(): void {
|
const {
|
request,
|
request: { user, method, url, async, password, headers, body }
|
} = this;
|
try {
|
const xhr = this.xhr = request.createXHR();
|
|
// set up the events before open XHR
|
// https://developer.mozilla.org/en/docs/Web/API/XMLHttpRequest/Using_XMLHttpRequest
|
// You need to add the event listeners before calling open() on the request.
|
// Otherwise the progress events will not fire.
|
this.setupEvents(xhr, request);
|
// open XHR
|
if (user) {
|
xhr.open(method, url, async, user, password);
|
} else {
|
xhr.open(method, url, async);
|
}
|
|
// timeout, responseType and withCredentials can be set once the XHR is open
|
if (async) {
|
xhr.timeout = request.timeout;
|
xhr.responseType = request.responseType as any;
|
}
|
|
if ('withCredentials' in xhr) {
|
xhr.withCredentials = !!request.withCredentials;
|
}
|
|
// set headers
|
this.setHeaders(xhr, headers);
|
|
// finally send the request
|
if (body) {
|
xhr.send(body);
|
} else {
|
xhr.send();
|
}
|
} catch (err) {
|
this.error(err);
|
}
|
}
|
|
private serializeBody(body: any, contentType?: string) {
|
if (!body || typeof body === 'string') {
|
return body;
|
} else if (root.FormData && body instanceof root.FormData) {
|
return body;
|
}
|
|
if (contentType) {
|
const splitIndex = contentType.indexOf(';');
|
if (splitIndex !== -1) {
|
contentType = contentType.substring(0, splitIndex);
|
}
|
}
|
|
switch (contentType) {
|
case 'application/x-www-form-urlencoded':
|
return Object.keys(body).map(key => `${encodeURIComponent(key)}=${encodeURIComponent(body[key])}`).join('&');
|
case 'application/json':
|
return JSON.stringify(body);
|
default:
|
return body;
|
}
|
}
|
|
private setHeaders(xhr: XMLHttpRequest, headers: Object) {
|
for (let key in headers) {
|
if (headers.hasOwnProperty(key)) {
|
xhr.setRequestHeader(key, headers[key]);
|
}
|
}
|
}
|
|
private getHeader(headers: {}, headerName: string): any {
|
for (let key in headers) {
|
if (key.toLowerCase() === headerName.toLowerCase()) {
|
return headers[key];
|
}
|
}
|
|
return undefined;
|
}
|
|
private setupEvents(xhr: XMLHttpRequest, request: AjaxRequest) {
|
const progressSubscriber = request.progressSubscriber;
|
|
function xhrTimeout(this: XMLHttpRequest, e: ProgressEvent): void {
|
const {subscriber, progressSubscriber, request } = (<any>xhrTimeout);
|
if (progressSubscriber) {
|
progressSubscriber.error(e);
|
}
|
let error;
|
try {
|
error = new AjaxTimeoutError(this, request); // TODO: Make betterer.
|
} catch (err) {
|
error = err;
|
}
|
subscriber.error(error);
|
}
|
xhr.ontimeout = xhrTimeout;
|
(<any>xhrTimeout).request = request;
|
(<any>xhrTimeout).subscriber = this;
|
(<any>xhrTimeout).progressSubscriber = progressSubscriber;
|
if (xhr.upload && 'withCredentials' in xhr) {
|
if (progressSubscriber) {
|
let xhrProgress: (e: ProgressEvent) => void;
|
xhrProgress = function(e: ProgressEvent) {
|
const { progressSubscriber } = (<any>xhrProgress);
|
progressSubscriber.next(e);
|
};
|
if (root.XDomainRequest) {
|
xhr.onprogress = xhrProgress;
|
} else {
|
xhr.upload.onprogress = xhrProgress;
|
}
|
(<any>xhrProgress).progressSubscriber = progressSubscriber;
|
}
|
let xhrError: (e: any) => void;
|
xhrError = function(this: XMLHttpRequest, e: ErrorEvent) {
|
const { progressSubscriber, subscriber, request } = (<any>xhrError);
|
if (progressSubscriber) {
|
progressSubscriber.error(e);
|
}
|
let error;
|
try {
|
error = new AjaxError('ajax error', this, request);
|
} catch (err) {
|
error = err;
|
}
|
subscriber.error(error);
|
};
|
xhr.onerror = xhrError;
|
(<any>xhrError).request = request;
|
(<any>xhrError).subscriber = this;
|
(<any>xhrError).progressSubscriber = progressSubscriber;
|
}
|
|
function xhrReadyStateChange(this: XMLHttpRequest, e: Event) {
|
return;
|
}
|
xhr.onreadystatechange = xhrReadyStateChange;
|
(<any>xhrReadyStateChange).subscriber = this;
|
(<any>xhrReadyStateChange).progressSubscriber = progressSubscriber;
|
(<any>xhrReadyStateChange).request = request;
|
|
function xhrLoad(this: XMLHttpRequest, e: Event) {
|
const { subscriber, progressSubscriber, request } = (<any>xhrLoad);
|
if (this.readyState === 4) {
|
// normalize IE9 bug (http://bugs.jquery.com/ticket/1450)
|
let status: number = this.status === 1223 ? 204 : this.status;
|
let response: any = (this.responseType === 'text' ? (
|
this.response || this.responseText) : this.response);
|
|
// fix status code when it is 0 (0 status is undocumented).
|
// Occurs when accessing file resources or on Android 4.1 stock browser
|
// while retrieving files from application cache.
|
if (status === 0) {
|
status = response ? 200 : 0;
|
}
|
|
// 4xx and 5xx should error (https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html)
|
if (status < 400) {
|
if (progressSubscriber) {
|
progressSubscriber.complete();
|
}
|
subscriber.next(e);
|
subscriber.complete();
|
} else {
|
if (progressSubscriber) {
|
progressSubscriber.error(e);
|
}
|
let error;
|
try {
|
error = new AjaxError('ajax error ' + status, this, request);
|
} catch (err) {
|
error = err;
|
}
|
subscriber.error(error);
|
}
|
}
|
}
|
xhr.onload = xhrLoad;
|
(<any>xhrLoad).subscriber = this;
|
(<any>xhrLoad).progressSubscriber = progressSubscriber;
|
(<any>xhrLoad).request = request;
|
}
|
|
unsubscribe() {
|
const { done, xhr } = this;
|
if (!done && xhr && xhr.readyState !== 4 && typeof xhr.abort === 'function') {
|
xhr.abort();
|
}
|
super.unsubscribe();
|
}
|
}
|
|
/**
|
* A normalized AJAX response.
|
*
|
* @see {@link ajax}
|
*
|
* @class AjaxResponse
|
*/
|
export class AjaxResponse {
|
/** @type {number} The HTTP status code */
|
status: number;
|
|
/** @type {string|ArrayBuffer|Document|object|any} The response data */
|
response: any;
|
|
/** @type {string} The raw responseText */
|
responseText: string;
|
|
/** @type {string} The responseType (e.g. 'json', 'arraybuffer', or 'xml') */
|
responseType: string;
|
|
constructor(public originalEvent: Event, public xhr: XMLHttpRequest, public request: AjaxRequest) {
|
this.status = xhr.status;
|
this.responseType = xhr.responseType || request.responseType;
|
this.response = parseXhrResponse(this.responseType, xhr);
|
}
|
}
|
|
export type AjaxErrorNames = 'AjaxError' | 'AjaxTimeoutError';
|
|
/**
|
* A normalized AJAX error.
|
*
|
* @see {@link ajax}
|
*
|
* @class AjaxError
|
*/
|
export interface AjaxError extends Error {
|
/** @type {XMLHttpRequest} The XHR instance associated with the error */
|
xhr: XMLHttpRequest;
|
|
/** @type {AjaxRequest} The AjaxRequest associated with the error */
|
request: AjaxRequest;
|
|
/** @type {number} The HTTP status code */
|
status: number;
|
|
/** @type {string} The responseType (e.g. 'json', 'arraybuffer', or 'xml') */
|
responseType: string;
|
|
/** @type {string|ArrayBuffer|Document|object|any} The response data */
|
response: any;
|
}
|
|
export interface AjaxErrorCtor {
|
new(message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError;
|
}
|
|
const AjaxErrorImpl = (() => {
|
function AjaxErrorImpl(this: any, message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError {
|
Error.call(this);
|
this.message = message;
|
this.name = 'AjaxError';
|
this.xhr = xhr;
|
this.request = request;
|
this.status = xhr.status;
|
this.responseType = xhr.responseType || request.responseType;
|
this.response = parseXhrResponse(this.responseType, xhr);
|
return this;
|
}
|
AjaxErrorImpl.prototype = Object.create(Error.prototype);
|
return AjaxErrorImpl;
|
})();
|
|
export const AjaxError: AjaxErrorCtor = AjaxErrorImpl as any;
|
|
function parseJson(xhr: XMLHttpRequest) {
|
// HACK(benlesh): TypeScript shennanigans
|
// tslint:disable-next-line:no-any XMLHttpRequest is defined to always have 'response' inferring xhr as never for the else clause.
|
if ('response' in (xhr as any)) {
|
//IE does not support json as responseType, parse it internally
|
return xhr.responseType ? xhr.response : JSON.parse(xhr.response || xhr.responseText || 'null');
|
} else {
|
return JSON.parse((xhr as any).responseText || 'null');
|
}
|
}
|
|
function parseXhrResponse(responseType: string, xhr: XMLHttpRequest) {
|
switch (responseType) {
|
case 'json':
|
return parseJson(xhr);
|
case 'xml':
|
return xhr.responseXML;
|
case 'text':
|
default:
|
// HACK(benlesh): TypeScript shennanigans
|
// tslint:disable-next-line:no-any XMLHttpRequest is defined to always have 'response' inferring xhr as never for the else sub-expression.
|
return ('response' in (xhr as any)) ? xhr.response : xhr.responseText;
|
}
|
}
|
|
export interface AjaxTimeoutError extends AjaxError {
|
}
|
|
export interface AjaxTimeoutErrorCtor {
|
new(xhr: XMLHttpRequest, request: AjaxRequest): AjaxTimeoutError;
|
}
|
|
function AjaxTimeoutErrorImpl(this: any, xhr: XMLHttpRequest, request: AjaxRequest) {
|
AjaxError.call(this, 'ajax timeout', xhr, request);
|
this.name = 'AjaxTimeoutError';
|
return this;
|
}
|
|
/**
|
* @see {@link ajax}
|
*
|
* @class AjaxTimeoutError
|
*/
|
export const AjaxTimeoutError: AjaxTimeoutErrorCtor = AjaxTimeoutErrorImpl as any;
|
