angular2
Version:
Angular 2 - a web framework for modern web apps
194 lines • 24.6 kB
JavaScript
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc);
switch (arguments.length) {
case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
}
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
import { isString, isPresent } from 'angular2/src/facade/lang';
import { makeTypeError } from 'angular2/src/facade/exceptions';
import { Injectable } from 'angular2/core';
import { ConnectionBackend } from './interfaces';
import { Request } from './static_request';
import { RequestOptions } from './base_request_options';
import { RequestMethods } from './enums';
function httpRequest(backend, request) {
return backend.createConnection(request).response;
}
function mergeOptions(defaultOpts, providedOpts, method, url) {
var newOptions = defaultOpts;
if (isPresent(providedOpts)) {
// Hack so Dart can used named parameters
return newOptions.merge(new RequestOptions({
method: providedOpts.method || method,
url: providedOpts.url || url,
search: providedOpts.search,
headers: providedOpts.headers,
body: providedOpts.body
}));
}
if (isPresent(method)) {
return newOptions.merge(new RequestOptions({ method: method, url: url }));
}
else {
return newOptions.merge(new RequestOptions({ url: url }));
}
}
/**
* Performs http requests using `XMLHttpRequest` as the default backend.
*
* `Http` is available as an injectable class, with methods to perform http requests. Calling
* `request` returns an {@link Observable} which will emit a single {@link Response} when a
* response is received.
*
* ### Example
*
* ```typescript
* import {Http, HTTP_PROVIDERS} from 'angular2/http';
* @Component({
* selector: 'http-app',
* viewProviders: [HTTP_PROVIDERS],
* templateUrl: 'people.html'
* })
* class PeopleComponent {
* constructor(http: Http) {
* http.get('people.json')
* // Call map on the response observable to get the parsed people object
* .map(res => res.json())
* // Subscribe to the observable to get the parsed people object and attach it to the
* // component
* .subscribe(people => this.people = people);
* }
* }
* ```
*
*
* ### Example
*
* ```
* http.get('people.json').observer({next: (value) => this.people = value});
* ```
*
* The default construct used to perform requests, `XMLHttpRequest`, is abstracted as a "Backend" (
* {@link XHRBackend} in this case), which could be mocked with dependency injection by replacing
* the {@link XHRBackend} provider, as in the following example:
*
* ### Example
*
* ```typescript
* import {MockBackend, BaseRequestOptions, Http} from 'angular2/http';
* var injector = Injector.resolveAndCreate([
* BaseRequestOptions,
* MockBackend,
* provide(Http, {useFactory:
* function(backend, defaultOptions) {
* return new Http(backend, defaultOptions);
* },
* deps: [MockBackend, BaseRequestOptions]})
* ]);
* var http = injector.get(Http);
* http.get('request-from-mock-backend.json').subscribe((res:Response) => doSomething(res));
* ```
*
**/
export let Http = class {
constructor(_backend, _defaultOptions) {
this._backend = _backend;
this._defaultOptions = _defaultOptions;
}
/**
* Performs any type of http request. First argument is required, and can either be a url or
* a {@link Request} instance. If the first argument is a url, an optional {@link RequestOptions}
* object can be provided as the 2nd argument. The options object will be merged with the values
* of {@link BaseRequestOptions} before performing the request.
*/
request(url, options) {
var responseObservable;
if (isString(url)) {
responseObservable = httpRequest(this._backend, new Request(mergeOptions(this._defaultOptions, options, RequestMethods.Get, url)));
}
else if (url instanceof Request) {
responseObservable = httpRequest(this._backend, url);
}
else {
throw makeTypeError('First argument must be a url string or Request instance.');
}
return responseObservable;
}
/**
* Performs a request with `get` http method.
*/
get(url, options) {
return httpRequest(this._backend, new Request(mergeOptions(this._defaultOptions, options, RequestMethods.Get, url)));
}
/**
* Performs a request with `post` http method.
*/
post(url, body, options) {
return httpRequest(this._backend, new Request(mergeOptions(this._defaultOptions.merge(new RequestOptions({ body: body })), options, RequestMethods.Post, url)));
}
/**
* Performs a request with `put` http method.
*/
put(url, body, options) {
return httpRequest(this._backend, new Request(mergeOptions(this._defaultOptions.merge(new RequestOptions({ body: body })), options, RequestMethods.Put, url)));
}
/**
* Performs a request with `delete` http method.
*/
delete(url, options) {
return httpRequest(this._backend, new Request(mergeOptions(this._defaultOptions, options, RequestMethods.Delete, url)));
}
/**
* Performs a request with `patch` http method.
*/
patch(url, body, options) {
return httpRequest(this._backend, new Request(mergeOptions(this._defaultOptions.merge(new RequestOptions({ body: body })), options, RequestMethods.Patch, url)));
}
/**
* Performs a request with `head` http method.
*/
head(url, options) {
return httpRequest(this._backend, new Request(mergeOptions(this._defaultOptions, options, RequestMethods.Head, url)));
}
};
Http = __decorate([
Injectable(),
__metadata('design:paramtypes', [ConnectionBackend, RequestOptions])
], Http);
export let Jsonp = class extends Http {
constructor(backend, defaultOptions) {
super(backend, defaultOptions);
}
/**
* Performs any type of http request. First argument is required, and can either be a url or
* a {@link Request} instance. If the first argument is a url, an optional {@link RequestOptions}
* object can be provided as the 2nd argument. The options object will be merged with the values
* of {@link BaseRequestOptions} before performing the request.
*/
request(url, options) {
var responseObservable;
if (isString(url)) {
url = new Request(mergeOptions(this._defaultOptions, options, RequestMethods.Get, url));
}
if (url instanceof Request) {
if (url.method !== RequestMethods.Get) {
makeTypeError('JSONP requests must use GET request method.');
}
responseObservable = httpRequest(this._backend, url);
}
else {
throw makeTypeError('First argument must be a url string or Request instance.');
}
return responseObservable;
}
};
Jsonp = __decorate([
Injectable(),
__metadata('design:paramtypes', [ConnectionBackend, RequestOptions])
], Jsonp);
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.js","sourceRoot":"","sources":["angular2/src/http/http.ts"],"names":["httpRequest","mergeOptions","Http","Http.constructor","Http.request","Http.get","Http.post","Http.put","Http.delete","Http.patch","Http.head","Jsonp","Jsonp.constructor","Jsonp.request"],"mappings":"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","sourcesContent":["import {isString, isPresent, isBlank} from 'angular2/src/facade/lang';\nimport {makeTypeError} from 'angular2/src/facade/exceptions';\nimport {Injectable} from 'angular2/core';\nimport {RequestOptionsArgs, Connection, ConnectionBackend} from './interfaces';\nimport {Request} from './static_request';\nimport {Response} from './static_response';\nimport {BaseRequestOptions, RequestOptions} from './base_request_options';\nimport {RequestMethods} from './enums';\nimport {Observable} from 'angular2/core';\n\nfunction httpRequest(backend: ConnectionBackend, request: Request): Observable<Response> {\n  return backend.createConnection(request).response;\n}\n\nfunction mergeOptions(defaultOpts, providedOpts, method, url): RequestOptions {\n  var newOptions = defaultOpts;\n  if (isPresent(providedOpts)) {\n    // Hack so Dart can used named parameters\n    return newOptions.merge(new RequestOptions({\n      method: providedOpts.method || method,\n      url: providedOpts.url || url,\n      search: providedOpts.search,\n      headers: providedOpts.headers,\n      body: providedOpts.body\n    }));\n  }\n  if (isPresent(method)) {\n    return newOptions.merge(new RequestOptions({method: method, url: url}));\n  } else {\n    return newOptions.merge(new RequestOptions({url: url}));\n  }\n}\n\n/**\n * Performs http requests using `XMLHttpRequest` as the default backend.\n *\n * `Http` is available as an injectable class, with methods to perform http requests. Calling\n * `request` returns an {@link Observable} which will emit a single {@link Response} when a\n * response is received.\n *\n * ### Example\n *\n * ```typescript\n * import {Http, HTTP_PROVIDERS} from 'angular2/http';\n * @Component({\n *   selector: 'http-app',\n *   viewProviders: [HTTP_PROVIDERS],\n *   templateUrl: 'people.html'\n * })\n * class PeopleComponent {\n *   constructor(http: Http) {\n *     http.get('people.json')\n *       // Call map on the response observable to get the parsed people object\n *       .map(res => res.json())\n *       // Subscribe to the observable to get the parsed people object and attach it to the\n *       // component\n *       .subscribe(people => this.people = people);\n *   }\n * }\n * ```\n *\n *\n * ### Example\n *\n * ```\n * http.get('people.json').observer({next: (value) => this.people = value});\n * ```\n *\n * The default construct used to perform requests, `XMLHttpRequest`, is abstracted as a \"Backend\" (\n * {@link XHRBackend} in this case), which could be mocked with dependency injection by replacing\n * the {@link XHRBackend} provider, as in the following example:\n *\n * ### Example\n *\n * ```typescript\n * import {MockBackend, BaseRequestOptions, Http} from 'angular2/http';\n * var injector = Injector.resolveAndCreate([\n *   BaseRequestOptions,\n *   MockBackend,\n *   provide(Http, {useFactory:\n *       function(backend, defaultOptions) {\n *         return new Http(backend, defaultOptions);\n *       },\n *       deps: [MockBackend, BaseRequestOptions]})\n * ]);\n * var http = injector.get(Http);\n * http.get('request-from-mock-backend.json').subscribe((res:Response) => doSomething(res));\n * ```\n *\n **/\n@Injectable()\nexport class Http {\n  constructor(protected _backend: ConnectionBackend, protected _defaultOptions: RequestOptions) {}\n\n  /**\n   * Performs any type of http request. First argument is required, and can either be a url or\n   * a {@link Request} instance. If the first argument is a url, an optional {@link RequestOptions}\n   * object can be provided as the 2nd argument. The options object will be merged with the values\n   * of {@link BaseRequestOptions} before performing the request.\n   */\n  request(url: string | Request, options?: RequestOptionsArgs): Observable<Response> {\n    var responseObservable: any;\n    if (isString(url)) {\n      responseObservable = httpRequest(\n          this._backend,\n          new Request(mergeOptions(this._defaultOptions, options, RequestMethods.Get, url)));\n    } else if (url instanceof Request) {\n      responseObservable = httpRequest(this._backend, url);\n    } else {\n      throw makeTypeError('First argument must be a url string or Request instance.');\n    }\n    return responseObservable;\n  }\n\n  /**\n   * Performs a request with `get` http method.\n   */\n  get(url: string, options?: RequestOptionsArgs): Observable<Response> {\n    return httpRequest(this._backend, new Request(mergeOptions(this._defaultOptions, options,\n                                                               RequestMethods.Get, url)));\n  }\n\n  /**\n   * Performs a request with `post` http method.\n   */\n  post(url: string, body: string, options?: RequestOptionsArgs): Observable<Response> {\n    return httpRequest(\n        this._backend,\n        new Request(mergeOptions(this._defaultOptions.merge(new RequestOptions({body: body})),\n                                 options, RequestMethods.Post, url)));\n  }\n\n  /**\n   * Performs a request with `put` http method.\n   */\n  put(url: string, body: string, options?: RequestOptionsArgs): Observable<Response> {\n    return httpRequest(\n        this._backend,\n        new Request(mergeOptions(this._defaultOptions.merge(new RequestOptions({body: body})),\n                                 options, RequestMethods.Put, url)));\n  }\n\n  /**\n   * Performs a request with `delete` http method.\n   */\n  delete (url: string, options?: RequestOptionsArgs): Observable<Response> {\n    return httpRequest(this._backend, new Request(mergeOptions(this._defaultOptions, options,\n                                                               RequestMethods.Delete, url)));\n  }\n\n  /**\n   * Performs a request with `patch` http method.\n   */\n  patch(url: string, body: string, options?: RequestOptionsArgs): Observable<Response> {\n    return httpRequest(\n        this._backend,\n        new Request(mergeOptions(this._defaultOptions.merge(new RequestOptions({body: body})),\n                                 options, RequestMethods.Patch, url)));\n  }\n\n  /**\n   * Performs a request with `head` http method.\n   */\n  head(url: string, options?: RequestOptionsArgs): Observable<Response> {\n    return httpRequest(this._backend, new Request(mergeOptions(this._defaultOptions, options,\n                                                               RequestMethods.Head, url)));\n  }\n}\n\n@Injectable()\nexport class Jsonp extends Http {\n  constructor(backend: ConnectionBackend, defaultOptions: RequestOptions) {\n    super(backend, defaultOptions);\n  }\n\n  /**\n   * Performs any type of http request. First argument is required, and can either be a url or\n   * a {@link Request} instance. If the first argument is a url, an optional {@link RequestOptions}\n   * object can be provided as the 2nd argument. The options object will be merged with the values\n   * of {@link BaseRequestOptions} before performing the request.\n   */\n  request(url: string | Request, options?: RequestOptionsArgs): Observable<Response> {\n    var responseObservable: any;\n    if (isString(url)) {\n      url = new Request(mergeOptions(this._defaultOptions, options, RequestMethods.Get, url));\n    }\n    if (url instanceof Request) {\n      if (url.method !== RequestMethods.Get) {\n        makeTypeError('JSONP requests must use GET request method.');\n      }\n      responseObservable = httpRequest(this._backend, url);\n    } else {\n      throw makeTypeError('First argument must be a url string or Request instance.');\n    }\n    return responseObservable;\n  }\n}\n"]}