@angular/http
Version:
Angular - the http service
288 lines • 26.2 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { Injectable } from '@angular/core';
import { RequestOptions } from './base_request_options';
import { RequestMethod } from './enums';
import { ConnectionBackend } from './interfaces';
import { Request } from './static_request';
/**
* @param {?} backend
* @param {?} request
* @return {?}
*/
function httpRequest(backend, request) {
return backend.createConnection(request).response;
}
/**
* @param {?} defaultOpts
* @param {?} providedOpts
* @param {?} method
* @param {?} url
* @return {?}
*/
function mergeOptions(defaultOpts, providedOpts, method, url) {
/** @type {?} */
const newOptions = defaultOpts;
if (providedOpts) {
// Hack so Dart can used named parameters
return (/** @type {?} */ (newOptions.merge(new RequestOptions({
method: providedOpts.method || method,
url: providedOpts.url || url,
search: providedOpts.search,
params: providedOpts.params,
headers: providedOpts.headers,
body: providedOpts.body,
withCredentials: providedOpts.withCredentials,
responseType: providedOpts.responseType
}))));
}
return (/** @type {?} */ (newOptions.merge(new RequestOptions({ method, 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 `Observable` which will emit a single {\@link Response} when a
* response is received.
*
* \@usageNotes
* ### Example
*
* ```typescript
* import {Http, HTTP_PROVIDERS} from '\@angular/http';
* import {map} from 'rxjs/operators';
*
* \@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
* .pipe(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').subscribe((res:Response) => this.people = res.json());
* ```
*
* 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 {BaseRequestOptions, Http} from '\@angular/http';
* import {MockBackend} from '\@angular/http/testing';
* 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));
* ```
*
* @deprecated see https://angular.io/guide/http
* \@publicApi
*/
export class Http {
/**
* @param {?} _backend
* @param {?} _defaultOptions
*/
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.
* @param {?} url
* @param {?=} options
* @return {?}
*/
request(url, options) {
/** @type {?} */
let responseObservable;
if (typeof url === 'string') {
responseObservable = httpRequest(this._backend, new Request(mergeOptions(this._defaultOptions, options, RequestMethod.Get, (/** @type {?} */ (url)))));
}
else if (url instanceof Request) {
responseObservable = httpRequest(this._backend, url);
}
else {
throw new Error('First argument must be a url string or Request instance.');
}
return responseObservable;
}
/**
* Performs a request with `get` http method.
* @param {?} url
* @param {?=} options
* @return {?}
*/
get(url, options) {
return this.request(new Request(mergeOptions(this._defaultOptions, options, RequestMethod.Get, url)));
}
/**
* Performs a request with `post` http method.
* @param {?} url
* @param {?} body
* @param {?=} options
* @return {?}
*/
post(url, body, options) {
return this.request(new Request(mergeOptions(this._defaultOptions.merge(new RequestOptions({ body: body })), options, RequestMethod.Post, url)));
}
/**
* Performs a request with `put` http method.
* @param {?} url
* @param {?} body
* @param {?=} options
* @return {?}
*/
put(url, body, options) {
return this.request(new Request(mergeOptions(this._defaultOptions.merge(new RequestOptions({ body: body })), options, RequestMethod.Put, url)));
}
/**
* Performs a request with `delete` http method.
* @param {?} url
* @param {?=} options
* @return {?}
*/
delete(url, options) {
return this.request(new Request(mergeOptions(this._defaultOptions, options, RequestMethod.Delete, url)));
}
/**
* Performs a request with `patch` http method.
* @param {?} url
* @param {?} body
* @param {?=} options
* @return {?}
*/
patch(url, body, options) {
return this.request(new Request(mergeOptions(this._defaultOptions.merge(new RequestOptions({ body: body })), options, RequestMethod.Patch, url)));
}
/**
* Performs a request with `head` http method.
* @param {?} url
* @param {?=} options
* @return {?}
*/
head(url, options) {
return this.request(new Request(mergeOptions(this._defaultOptions, options, RequestMethod.Head, url)));
}
/**
* Performs a request with `options` http method.
* @param {?} url
* @param {?=} options
* @return {?}
*/
options(url, options) {
return this.request(new Request(mergeOptions(this._defaultOptions, options, RequestMethod.Options, url)));
}
}
Http.decorators = [
{ type: Injectable }
];
/** @nocollapse */
Http.ctorParameters = () => [
{ type: ConnectionBackend },
{ type: RequestOptions }
];
if (false) {
/**
* @type {?}
* @protected
*/
Http.prototype._backend;
/**
* @type {?}
* @protected
*/
Http.prototype._defaultOptions;
}
/**
* @deprecated see https://angular.io/guide/http
* \@publicApi
*/
export class Jsonp extends Http {
/**
* @param {?} backend
* @param {?} defaultOptions
*/
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.
*
* \@security Regular XHR is the safest alternative to JSONP for most applications, and is
* supported by all current browsers. Because JSONP creates a `<script>` element with
* contents retrieved from a remote source, attacker-controlled data introduced by an untrusted
* source could expose your application to XSS risks. Data exposed by JSONP may also be
* readable by malicious third-party websites. In addition, JSONP introduces potential risk for
* future security issues (e.g. content sniffing). For more detail, see the
* [Security Guide](http://g.co/ng/security).
* @param {?} url
* @param {?=} options
* @return {?}
*/
request(url, options) {
/** @type {?} */
let responseObservable;
if (typeof url === 'string') {
url =
new Request(mergeOptions(this._defaultOptions, options, RequestMethod.Get, (/** @type {?} */ (url))));
}
if (url instanceof Request) {
if (url.method !== RequestMethod.Get) {
throw new Error('JSONP requests must use GET request method.');
}
responseObservable = httpRequest(this._backend, url);
}
else {
throw new Error('First argument must be a url string or Request instance.');
}
return responseObservable;
}
}
Jsonp.decorators = [
{ type: Injectable }
];
/** @nocollapse */
Jsonp.ctorParameters = () => [
{ type: ConnectionBackend },
{ type: RequestOptions }
];
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.js","sourceRoot":"","sources":["../../../../../../packages/http/src/http.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Injectable} from '@angular/core';\nimport {Observable} from 'rxjs';\n\nimport {BaseRequestOptions, RequestOptions} from './base_request_options';\nimport {RequestMethod} from './enums';\nimport {ConnectionBackend, RequestArgs, RequestOptionsArgs} from './interfaces';\nimport {Request} from './static_request';\nimport {Response} from './static_response';\n\nfunction httpRequest(backend: ConnectionBackend, request: Request): Observable<Response> {\n  return backend.createConnection(request).response;\n}\n\nfunction mergeOptions(\n    defaultOpts: BaseRequestOptions, providedOpts: RequestOptionsArgs | undefined,\n    method: RequestMethod, url: string): RequestArgs {\n  const newOptions = defaultOpts;\n  if (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      params: providedOpts.params,\n      headers: providedOpts.headers,\n      body: providedOpts.body,\n      withCredentials: providedOpts.withCredentials,\n      responseType: providedOpts.responseType\n    })) as RequestArgs;\n  }\n\n  return newOptions.merge(new RequestOptions({method, url})) as RequestArgs;\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 `Observable` which will emit a single {@link Response} when a\n * response is received.\n *\n * @usageNotes\n * ### Example\n *\n * ```typescript\n * import {Http, HTTP_PROVIDERS} from '@angular/http';\n * import {map} from 'rxjs/operators';\n *\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 *       .pipe(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').subscribe((res:Response) => this.people = res.json());\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 {BaseRequestOptions, Http} from '@angular/http';\n * import {MockBackend} from '@angular/http/testing';\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 * @deprecated see https://angular.io/guide/http\n * @publicApi\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    let responseObservable: any;\n    if (typeof url === 'string') {\n      responseObservable = httpRequest(\n          this._backend,\n          new Request(mergeOptions(this._defaultOptions, options, RequestMethod.Get, <string>url)));\n    } else if (url instanceof Request) {\n      responseObservable = httpRequest(this._backend, url);\n    } else {\n      throw new Error('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 this.request(\n        new Request(mergeOptions(this._defaultOptions, options, RequestMethod.Get, url)));\n  }\n\n  /**\n   * Performs a request with `post` http method.\n   */\n  post(url: string, body: any, options?: RequestOptionsArgs): Observable<Response> {\n    return this.request(new Request(mergeOptions(\n        this._defaultOptions.merge(new RequestOptions({body: body})), options, RequestMethod.Post,\n        url)));\n  }\n\n  /**\n   * Performs a request with `put` http method.\n   */\n  put(url: string, body: any, options?: RequestOptionsArgs): Observable<Response> {\n    return this.request(new Request(mergeOptions(\n        this._defaultOptions.merge(new RequestOptions({body: body})), options, RequestMethod.Put,\n        url)));\n  }\n\n  /**\n   * Performs a request with `delete` http method.\n   */\n  delete (url: string, options?: RequestOptionsArgs): Observable<Response> {\n    return this.request(\n        new Request(mergeOptions(this._defaultOptions, options, RequestMethod.Delete, url)));\n  }\n\n  /**\n   * Performs a request with `patch` http method.\n   */\n  patch(url: string, body: any, options?: RequestOptionsArgs): Observable<Response> {\n    return this.request(new Request(mergeOptions(\n        this._defaultOptions.merge(new RequestOptions({body: body})), options, RequestMethod.Patch,\n        url)));\n  }\n\n  /**\n   * Performs a request with `head` http method.\n   */\n  head(url: string, options?: RequestOptionsArgs): Observable<Response> {\n    return this.request(\n        new Request(mergeOptions(this._defaultOptions, options, RequestMethod.Head, url)));\n  }\n\n  /**\n   * Performs a request with `options` http method.\n   */\n  options(url: string, options?: RequestOptionsArgs): Observable<Response> {\n    return this.request(\n        new Request(mergeOptions(this._defaultOptions, options, RequestMethod.Options, url)));\n  }\n}\n\n\n/**\n * @deprecated see https://angular.io/guide/http\n * @publicApi\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   * @security Regular XHR is the safest alternative to JSONP for most applications, and is\n   * supported by all current browsers. Because JSONP creates a `<script>` element with\n   * contents retrieved from a remote source, attacker-controlled data introduced by an untrusted\n   * source could expose your application to XSS risks. Data exposed by JSONP may also be\n   * readable by malicious third-party websites. In addition, JSONP introduces potential risk for\n   * future security issues (e.g. content sniffing).  For more detail, see the\n   * [Security Guide](http://g.co/ng/security).\n   */\n  request(url: string|Request, options?: RequestOptionsArgs): Observable<Response> {\n    let responseObservable: any;\n    if (typeof url === 'string') {\n      url =\n          new Request(mergeOptions(this._defaultOptions, options, RequestMethod.Get, <string>url));\n    }\n    if (url instanceof Request) {\n      if (url.method !== RequestMethod.Get) {\n        throw new Error('JSONP requests must use GET request method.');\n      }\n      responseObservable = httpRequest(this._backend, url);\n    } else {\n      throw new Error('First argument must be a url string or Request instance.');\n    }\n    return responseObservable;\n  }\n}\n"]}