311 lines
27 KiB
JavaScript
311 lines
27 KiB
JavaScript
'use strict';/**
|
|
* @module
|
|
* @description
|
|
* The http module provides services to perform http requests. To get started, see the {@link Http}
|
|
* class.
|
|
*/
|
|
var core_1 = require('angular2/core');
|
|
var http_1 = require('./src/http/http');
|
|
var xhr_backend_1 = require('./src/http/backends/xhr_backend');
|
|
var jsonp_backend_1 = require('./src/http/backends/jsonp_backend');
|
|
var browser_xhr_1 = require('./src/http/backends/browser_xhr');
|
|
var browser_jsonp_1 = require('./src/http/backends/browser_jsonp');
|
|
var base_request_options_1 = require('./src/http/base_request_options');
|
|
var base_response_options_1 = require('./src/http/base_response_options');
|
|
var static_request_1 = require('./src/http/static_request');
|
|
exports.Request = static_request_1.Request;
|
|
var static_response_1 = require('./src/http/static_response');
|
|
exports.Response = static_response_1.Response;
|
|
var interfaces_1 = require('./src/http/interfaces');
|
|
exports.Connection = interfaces_1.Connection;
|
|
exports.ConnectionBackend = interfaces_1.ConnectionBackend;
|
|
var browser_xhr_2 = require('./src/http/backends/browser_xhr');
|
|
exports.BrowserXhr = browser_xhr_2.BrowserXhr;
|
|
var base_request_options_2 = require('./src/http/base_request_options');
|
|
exports.BaseRequestOptions = base_request_options_2.BaseRequestOptions;
|
|
exports.RequestOptions = base_request_options_2.RequestOptions;
|
|
var base_response_options_2 = require('./src/http/base_response_options');
|
|
exports.BaseResponseOptions = base_response_options_2.BaseResponseOptions;
|
|
exports.ResponseOptions = base_response_options_2.ResponseOptions;
|
|
var xhr_backend_2 = require('./src/http/backends/xhr_backend');
|
|
exports.XHRBackend = xhr_backend_2.XHRBackend;
|
|
exports.XHRConnection = xhr_backend_2.XHRConnection;
|
|
var jsonp_backend_2 = require('./src/http/backends/jsonp_backend');
|
|
exports.JSONPBackend = jsonp_backend_2.JSONPBackend;
|
|
exports.JSONPConnection = jsonp_backend_2.JSONPConnection;
|
|
var http_2 = require('./src/http/http');
|
|
exports.Http = http_2.Http;
|
|
exports.Jsonp = http_2.Jsonp;
|
|
var headers_1 = require('./src/http/headers');
|
|
exports.Headers = headers_1.Headers;
|
|
var enums_1 = require('./src/http/enums');
|
|
exports.ResponseType = enums_1.ResponseType;
|
|
exports.ReadyState = enums_1.ReadyState;
|
|
exports.RequestMethod = enums_1.RequestMethod;
|
|
var url_search_params_1 = require('./src/http/url_search_params');
|
|
exports.URLSearchParams = url_search_params_1.URLSearchParams;
|
|
/**
|
|
* Provides a basic set of injectables to use the {@link Http} service in any application.
|
|
*
|
|
* The `HTTP_PROVIDERS` should be included either in a component's injector,
|
|
* or in the root injector when bootstrapping an application.
|
|
*
|
|
* ### Example ([live demo](http://plnkr.co/edit/snj7Nv?p=preview))
|
|
*
|
|
* ```
|
|
* import {Component} from 'angular2/core';
|
|
* import {bootstrap} from 'angular2/platform/browser';
|
|
* import {NgFor} from 'angular2/common';
|
|
* import {HTTP_PROVIDERS, Http} from 'angular2/http';
|
|
*
|
|
* @Component({
|
|
* selector: 'app',
|
|
* providers: [HTTP_PROVIDERS],
|
|
* template: `
|
|
* <div>
|
|
* <h1>People</h1>
|
|
* <ul>
|
|
* <li *ngFor="#person of people">
|
|
* {{person.name}}
|
|
* </li>
|
|
* </ul>
|
|
* </div>
|
|
* `,
|
|
* directives: [NgFor]
|
|
* })
|
|
* export class App {
|
|
* people: Object[];
|
|
* constructor(http:Http) {
|
|
* http.get('people.json').subscribe(res => {
|
|
* this.people = res.json();
|
|
* });
|
|
* }
|
|
* active:boolean = false;
|
|
* toggleActiveState() {
|
|
* this.active = !this.active;
|
|
* }
|
|
* }
|
|
*
|
|
* bootstrap(App)
|
|
* .catch(err => console.error(err));
|
|
* ```
|
|
*
|
|
* The primary public API included in `HTTP_PROVIDERS` is the {@link Http} class.
|
|
* However, other providers required by `Http` are included,
|
|
* which may be beneficial to override in certain cases.
|
|
*
|
|
* The providers included in `HTTP_PROVIDERS` include:
|
|
* * {@link Http}
|
|
* * {@link XHRBackend}
|
|
* * `BrowserXHR` - Private factory to create `XMLHttpRequest` instances
|
|
* * {@link RequestOptions} - Bound to {@link BaseRequestOptions} class
|
|
* * {@link ResponseOptions} - Bound to {@link BaseResponseOptions} class
|
|
*
|
|
* There may be cases where it makes sense to extend the base request options,
|
|
* such as to add a search string to be appended to all URLs.
|
|
* To accomplish this, a new provider for {@link RequestOptions} should
|
|
* be added in the same injector as `HTTP_PROVIDERS`.
|
|
*
|
|
* ### Example ([live demo](http://plnkr.co/edit/aCMEXi?p=preview))
|
|
*
|
|
* ```
|
|
* import {provide} from 'angular2/core';
|
|
* import {bootstrap} from 'angular2/platform/browser';
|
|
* import {HTTP_PROVIDERS, BaseRequestOptions, RequestOptions} from 'angular2/http';
|
|
*
|
|
* class MyOptions extends BaseRequestOptions {
|
|
* search: string = 'coreTeam=true';
|
|
* }
|
|
*
|
|
* bootstrap(App, [HTTP_PROVIDERS, provide(RequestOptions, {useClass: MyOptions})])
|
|
* .catch(err => console.error(err));
|
|
* ```
|
|
*
|
|
* Likewise, to use a mock backend for unit tests, the {@link XHRBackend}
|
|
* provider should be bound to {@link MockBackend}.
|
|
*
|
|
* ### Example ([live demo](http://plnkr.co/edit/7LWALD?p=preview))
|
|
*
|
|
* ```
|
|
* import {provide} from 'angular2/core';
|
|
* import {bootstrap} from 'angular2/platform/browser';
|
|
* import {HTTP_PROVIDERS, Http, Response, XHRBackend} from 'angular2/http';
|
|
* import {MockBackend} from 'angular2/http/testing';
|
|
*
|
|
* var people = [{name: 'Jeff'}, {name: 'Tobias'}];
|
|
*
|
|
* var injector = Injector.resolveAndCreate([
|
|
* HTTP_PROVIDERS,
|
|
* MockBackend,
|
|
* provide(XHRBackend, {useExisting: MockBackend})
|
|
* ]);
|
|
* var http = injector.get(Http);
|
|
* var backend = injector.get(MockBackend);
|
|
*
|
|
* // Listen for any new requests
|
|
* backend.connections.observer({
|
|
* next: connection => {
|
|
* var response = new Response({body: people});
|
|
* setTimeout(() => {
|
|
* // Send a response to the request
|
|
* connection.mockRespond(response);
|
|
* });
|
|
* }
|
|
* });
|
|
*
|
|
* http.get('people.json').observer({
|
|
* next: res => {
|
|
* // Response came from mock backend
|
|
* console.log('first person', res.json()[0].name);
|
|
* }
|
|
* });
|
|
* ```
|
|
*/
|
|
exports.HTTP_PROVIDERS = [
|
|
// TODO(pascal): use factory type annotations once supported in DI
|
|
// issue: https://github.com/angular/angular/issues/3183
|
|
core_1.provide(http_1.Http, {
|
|
useFactory: function (xhrBackend, requestOptions) {
|
|
return new http_1.Http(xhrBackend, requestOptions);
|
|
},
|
|
deps: [xhr_backend_1.XHRBackend, base_request_options_1.RequestOptions]
|
|
}),
|
|
browser_xhr_1.BrowserXhr,
|
|
core_1.provide(base_request_options_1.RequestOptions, { useClass: base_request_options_1.BaseRequestOptions }),
|
|
core_1.provide(base_response_options_1.ResponseOptions, { useClass: base_response_options_1.BaseResponseOptions }),
|
|
xhr_backend_1.XHRBackend
|
|
];
|
|
/**
|
|
* See {@link HTTP_PROVIDERS} instead.
|
|
*
|
|
* @deprecated
|
|
*/
|
|
exports.HTTP_BINDINGS = exports.HTTP_PROVIDERS;
|
|
/**
|
|
* Provides a basic set of providers to use the {@link Jsonp} service in any application.
|
|
*
|
|
* The `JSONP_PROVIDERS` should be included either in a component's injector,
|
|
* or in the root injector when bootstrapping an application.
|
|
*
|
|
* ### Example ([live demo](http://plnkr.co/edit/vmeN4F?p=preview))
|
|
*
|
|
* ```
|
|
* import {Component} from 'angular2/core';
|
|
* import {NgFor} from 'angular2/common';
|
|
* import {JSONP_PROVIDERS, Jsonp} from 'angular2/http';
|
|
*
|
|
* @Component({
|
|
* selector: 'app',
|
|
* providers: [JSONP_PROVIDERS],
|
|
* template: `
|
|
* <div>
|
|
* <h1>People</h1>
|
|
* <ul>
|
|
* <li *ngFor="#person of people">
|
|
* {{person.name}}
|
|
* </li>
|
|
* </ul>
|
|
* </div>
|
|
* `,
|
|
* directives: [NgFor]
|
|
* })
|
|
* export class App {
|
|
* people: Array<Object>;
|
|
* constructor(jsonp:Jsonp) {
|
|
* jsonp.request('people.json').subscribe(res => {
|
|
* this.people = res.json();
|
|
* })
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* The primary public API included in `JSONP_PROVIDERS` is the {@link Jsonp} class.
|
|
* However, other providers required by `Jsonp` are included,
|
|
* which may be beneficial to override in certain cases.
|
|
*
|
|
* The providers included in `JSONP_PROVIDERS` include:
|
|
* * {@link Jsonp}
|
|
* * {@link JSONPBackend}
|
|
* * `BrowserJsonp` - Private factory
|
|
* * {@link RequestOptions} - Bound to {@link BaseRequestOptions} class
|
|
* * {@link ResponseOptions} - Bound to {@link BaseResponseOptions} class
|
|
*
|
|
* There may be cases where it makes sense to extend the base request options,
|
|
* such as to add a search string to be appended to all URLs.
|
|
* To accomplish this, a new provider for {@link RequestOptions} should
|
|
* be added in the same injector as `JSONP_PROVIDERS`.
|
|
*
|
|
* ### Example ([live demo](http://plnkr.co/edit/TFug7x?p=preview))
|
|
*
|
|
* ```
|
|
* import {provide} from 'angular2/core';
|
|
* import {bootstrap} from 'angular2/platform/browser';
|
|
* import {JSONP_PROVIDERS, BaseRequestOptions, RequestOptions} from 'angular2/http';
|
|
*
|
|
* class MyOptions extends BaseRequestOptions {
|
|
* search: string = 'coreTeam=true';
|
|
* }
|
|
*
|
|
* bootstrap(App, [JSONP_PROVIDERS, provide(RequestOptions, {useClass: MyOptions})])
|
|
* .catch(err => console.error(err));
|
|
* ```
|
|
*
|
|
* Likewise, to use a mock backend for unit tests, the {@link JSONPBackend}
|
|
* provider should be bound to {@link MockBackend}.
|
|
*
|
|
* ### Example ([live demo](http://plnkr.co/edit/HDqZWL?p=preview))
|
|
*
|
|
* ```
|
|
* import {provide, Injector} from 'angular2/core';
|
|
* import {JSONP_PROVIDERS, Jsonp, Response, JSONPBackend} from 'angular2/http';
|
|
* import {MockBackend} from 'angular2/http/testing';
|
|
*
|
|
* var people = [{name: 'Jeff'}, {name: 'Tobias'}];
|
|
* var injector = Injector.resolveAndCreate([
|
|
* JSONP_PROVIDERS,
|
|
* MockBackend,
|
|
* provide(JSONPBackend, {useExisting: MockBackend})
|
|
* ]);
|
|
* var jsonp = injector.get(Jsonp);
|
|
* var backend = injector.get(MockBackend);
|
|
*
|
|
* // Listen for any new requests
|
|
* backend.connections.observer({
|
|
* next: connection => {
|
|
* var response = new Response({body: people});
|
|
* setTimeout(() => {
|
|
* // Send a response to the request
|
|
* connection.mockRespond(response);
|
|
* });
|
|
* }
|
|
* });
|
|
|
|
* jsonp.get('people.json').observer({
|
|
* next: res => {
|
|
* // Response came from mock backend
|
|
* console.log('first person', res.json()[0].name);
|
|
* }
|
|
* });
|
|
* ```
|
|
*/
|
|
exports.JSONP_PROVIDERS = [
|
|
// TODO(pascal): use factory type annotations once supported in DI
|
|
// issue: https://github.com/angular/angular/issues/3183
|
|
core_1.provide(http_1.Jsonp, {
|
|
useFactory: function (jsonpBackend, requestOptions) {
|
|
return new http_1.Jsonp(jsonpBackend, requestOptions);
|
|
},
|
|
deps: [jsonp_backend_1.JSONPBackend, base_request_options_1.RequestOptions]
|
|
}),
|
|
browser_jsonp_1.BrowserJsonp,
|
|
core_1.provide(base_request_options_1.RequestOptions, { useClass: base_request_options_1.BaseRequestOptions }),
|
|
core_1.provide(base_response_options_1.ResponseOptions, { useClass: base_response_options_1.BaseResponseOptions }),
|
|
core_1.provide(jsonp_backend_1.JSONPBackend, { useClass: jsonp_backend_1.JSONPBackend_ })
|
|
];
|
|
/**
|
|
* See {@link JSONP_PROVIDERS} instead.
|
|
*
|
|
* @deprecated
|
|
*/
|
|
exports.JSON_BINDINGS = exports.JSONP_PROVIDERS;
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.js","sourceRoot":"","sources":["angular2/http.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,qBAAgC,eAAe,CAAC,CAAA;AAChD,qBAA0B,iBAAiB,CAAC,CAAA;AAC5C,4BAAwC,iCAAiC,CAAC,CAAA;AAC1E,8BAA2D,mCAAmC,CAAC,CAAA;AAC/F,4BAAyB,iCAAiC,CAAC,CAAA;AAC3D,8BAA2B,mCAAmC,CAAC,CAAA;AAC/D,qCAAiD,iCAAiC,CAAC,CAAA;AAEnF,sCAAmD,kCAAkC,CAAC,CAAA;AACtF,+BAAsB,2BAA2B,CAAC;AAA1C,2CAA0C;AAClD,gCAAuB,4BAA4B,CAAC;AAA5C,8CAA4C;AAEpD,2BAKO,uBAAuB,CAAC;AAF7B,6CAAU;AACV,2DAC6B;AAE/B,4BAAyB,iCAAiC,CAAC;AAAnD,8CAAmD;AAC3D,qCAAiD,iCAAiC,CAAC;AAA3E,uEAAkB;AAAE,+DAAuD;AACnF,sCAAmD,kCAAkC,CAAC;AAA9E,0EAAmB;AAAE,kEAAyD;AACtF,4BAAwC,iCAAiC,CAAC;AAAlE,8CAAU;AAAE,oDAAsD;AAC1E,8BAA4C,mCAAmC,CAAC;AAAxE,oDAAY;AAAE,0DAA0D;AAChF,qBAA0B,iBAAiB,CAAC;AAApC,2BAAI;AAAE,6BAA8B;AAE5C,wBAAsB,oBAAoB,CAAC;AAAnC,oCAAmC;AAE3C,sBAAsD,kBAAkB,CAAC;AAAjE,4CAAY;AAAE,wCAAU;AAAE,8CAAuC;AACzE,kCAA8B,8BAA8B,CAAC;AAArD,8DAAqD;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoHG;AACU,sBAAc,GAAU;IACnC,kEAAkE;IAClE,wDAAwD;IACxD,cAAO,CAAC,WAAI,EACJ;QACE,UAAU,EAAE,UAAC,UAAsB,EAAE,cAA8B;mBACnD,IAAI,WAAI,CAAC,UAAU,EAAE,cAAc,CAAC;QAApC,CAAoC;QACpD,IAAI,EAAE,CAAC,wBAAU,EAAE,qCAAc,CAAC;KACnC,CAAC;IACV,wBAAU;IACV,cAAO,CAAC,qCAAc,EAAE,EAAC,QAAQ,EAAE,yCAAkB,EAAC,CAAC;IACvD,cAAO,CAAC,uCAAe,EAAE,EAAC,QAAQ,EAAE,2CAAmB,EAAC,CAAC;IACzD,wBAAU;CACX,CAAC;AAEF;;;;GAIG;AACU,qBAAa,GAAG,sBAAc,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0GG;AACU,uBAAe,GAAU;IACpC,kEAAkE;IAClE,wDAAwD;IACxD,cAAO,CAAC,YAAK,EACL;QACE,UAAU,EAAE,UAAC,YAA0B,EAAE,cAA8B;mBACvD,IAAI,YAAK,CAAC,YAAY,EAAE,cAAc,CAAC;QAAvC,CAAuC;QACvD,IAAI,EAAE,CAAC,4BAAY,EAAE,qCAAc,CAAC;KACrC,CAAC;IACV,4BAAY;IACZ,cAAO,CAAC,qCAAc,EAAE,EAAC,QAAQ,EAAE,yCAAkB,EAAC,CAAC;IACvD,cAAO,CAAC,uCAAe,EAAE,EAAC,QAAQ,EAAE,2CAAmB,EAAC,CAAC;IACzD,cAAO,CAAC,4BAAY,EAAE,EAAC,QAAQ,EAAE,6BAAa,EAAC,CAAC;CACjD,CAAC;AAEF;;;;GAIG;AACU,qBAAa,GAAG,uBAAe,CAAC","sourcesContent":["/**\n * @module\n * @description\n * The http module provides services to perform http requests. To get started, see the {@link Http}\n * class.\n */\nimport {provide, Provider} from 'angular2/core';\nimport {Http, Jsonp} from './src/http/http';\nimport {XHRBackend, XHRConnection} from './src/http/backends/xhr_backend';\nimport {JSONPBackend, JSONPBackend_, JSONPConnection} from './src/http/backends/jsonp_backend';\nimport {BrowserXhr} from './src/http/backends/browser_xhr';\nimport {BrowserJsonp} from './src/http/backends/browser_jsonp';\nimport {BaseRequestOptions, RequestOptions} from './src/http/base_request_options';\nimport {ConnectionBackend} from './src/http/interfaces';\nimport {BaseResponseOptions, ResponseOptions} from './src/http/base_response_options';\nexport {Request} from './src/http/static_request';\nexport {Response} from './src/http/static_response';\n\nexport {\n  RequestOptionsArgs,\n  ResponseOptionsArgs,\n  Connection,\n  ConnectionBackend\n} from './src/http/interfaces';\n\nexport {BrowserXhr} from './src/http/backends/browser_xhr';\nexport {BaseRequestOptions, RequestOptions} from './src/http/base_request_options';\nexport {BaseResponseOptions, ResponseOptions} from './src/http/base_response_options';\nexport {XHRBackend, XHRConnection} from './src/http/backends/xhr_backend';\nexport {JSONPBackend, JSONPConnection} from './src/http/backends/jsonp_backend';\nexport {Http, Jsonp} from './src/http/http';\n\nexport {Headers} from './src/http/headers';\n\nexport {ResponseType, ReadyState, RequestMethod} from './src/http/enums';\nexport {URLSearchParams} from './src/http/url_search_params';\n\n/**\n * Provides a basic set of injectables to use the {@link Http} service in any application.\n *\n * The `HTTP_PROVIDERS` should be included either in a component's injector,\n * or in the root injector when bootstrapping an application.\n *\n * ### Example ([live demo](http://plnkr.co/edit/snj7Nv?p=preview))\n *\n * ```\n * import {Component} from 'angular2/core';\n * import {bootstrap} from 'angular2/platform/browser';\n * import {NgFor} from 'angular2/common';\n * import {HTTP_PROVIDERS, Http} from 'angular2/http';\n *\n * @Component({\n *   selector: 'app',\n *   providers: [HTTP_PROVIDERS],\n *   template: `\n *     <div>\n *       <h1>People</h1>\n *       <ul>\n *         <li *ngFor=\"#person of people\">\n *           {{person.name}}\n *         </li>\n *       </ul>\n *     </div>\n *   `,\n *   directives: [NgFor]\n * })\n * export class App {\n *   people: Object[];\n *   constructor(http:Http) {\n *     http.get('people.json').subscribe(res => {\n *       this.people = res.json();\n *     });\n *   }\n *   active:boolean = false;\n *   toggleActiveState() {\n *     this.active = !this.active;\n *   }\n * }\n *\n * bootstrap(App)\n *   .catch(err => console.error(err));\n * ```\n *\n * The primary public API included in `HTTP_PROVIDERS` is the {@link Http} class.\n * However, other providers required by `Http` are included,\n * which may be beneficial to override in certain cases.\n *\n * The providers included in `HTTP_PROVIDERS` include:\n *  * {@link Http}\n *  * {@link XHRBackend}\n *  * `BrowserXHR` - Private factory to create `XMLHttpRequest` instances\n *  * {@link RequestOptions} - Bound to {@link BaseRequestOptions} class\n *  * {@link ResponseOptions} - Bound to {@link BaseResponseOptions} class\n *\n * There may be cases where it makes sense to extend the base request options,\n * such as to add a search string to be appended to all URLs.\n * To accomplish this, a new provider for {@link RequestOptions} should\n * be added in the same injector as `HTTP_PROVIDERS`.\n *\n * ### Example ([live demo](http://plnkr.co/edit/aCMEXi?p=preview))\n *\n * ```\n * import {provide} from 'angular2/core';\n * import {bootstrap} from 'angular2/platform/browser';\n * import {HTTP_PROVIDERS, BaseRequestOptions, RequestOptions} from 'angular2/http';\n *\n * class MyOptions extends BaseRequestOptions {\n *   search: string = 'coreTeam=true';\n * }\n *\n * bootstrap(App, [HTTP_PROVIDERS, provide(RequestOptions, {useClass: MyOptions})])\n *   .catch(err => console.error(err));\n * ```\n *\n * Likewise, to use a mock backend for unit tests, the {@link XHRBackend}\n * provider should be bound to {@link MockBackend}.\n *\n * ### Example ([live demo](http://plnkr.co/edit/7LWALD?p=preview))\n *\n * ```\n * import {provide} from 'angular2/core';\n * import {bootstrap} from 'angular2/platform/browser';\n * import {HTTP_PROVIDERS, Http, Response, XHRBackend} from 'angular2/http';\n * import {MockBackend} from 'angular2/http/testing';\n *\n * var people = [{name: 'Jeff'}, {name: 'Tobias'}];\n *\n * var injector = Injector.resolveAndCreate([\n *   HTTP_PROVIDERS,\n *   MockBackend,\n *   provide(XHRBackend, {useExisting: MockBackend})\n * ]);\n * var http = injector.get(Http);\n * var backend = injector.get(MockBackend);\n *\n * // Listen for any new requests\n * backend.connections.observer({\n *   next: connection => {\n *     var response = new Response({body: people});\n *     setTimeout(() => {\n *       // Send a response to the request\n *       connection.mockRespond(response);\n *     });\n *   }\n * });\n *\n * http.get('people.json').observer({\n *   next: res => {\n *     // Response came from mock backend\n *     console.log('first person', res.json()[0].name);\n *   }\n * });\n * ```\n */\nexport const HTTP_PROVIDERS: any[] = [\n  // TODO(pascal): use factory type annotations once supported in DI\n  // issue: https://github.com/angular/angular/issues/3183\n  provide(Http,\n          {\n            useFactory: (xhrBackend: XHRBackend, requestOptions: RequestOptions) =>\n                            new Http(xhrBackend, requestOptions),\n            deps: [XHRBackend, RequestOptions]\n          }),\n  BrowserXhr,\n  provide(RequestOptions, {useClass: BaseRequestOptions}),\n  provide(ResponseOptions, {useClass: BaseResponseOptions}),\n  XHRBackend\n];\n\n/**\n * See {@link HTTP_PROVIDERS} instead.\n *\n * @deprecated\n */\nexport const HTTP_BINDINGS = HTTP_PROVIDERS;\n\n/**\n * Provides a basic set of providers to use the {@link Jsonp} service in any application.\n *\n * The `JSONP_PROVIDERS` should be included either in a component's injector,\n * or in the root injector when bootstrapping an application.\n *\n * ### Example ([live demo](http://plnkr.co/edit/vmeN4F?p=preview))\n *\n * ```\n * import {Component} from 'angular2/core';\n * import {NgFor} from 'angular2/common';\n * import {JSONP_PROVIDERS, Jsonp} from 'angular2/http';\n *\n * @Component({\n *   selector: 'app',\n *   providers: [JSONP_PROVIDERS],\n *   template: `\n *     <div>\n *       <h1>People</h1>\n *       <ul>\n *         <li *ngFor=\"#person of people\">\n *           {{person.name}}\n *         </li>\n *       </ul>\n *     </div>\n *   `,\n *   directives: [NgFor]\n * })\n * export class App {\n *   people: Array<Object>;\n *   constructor(jsonp:Jsonp) {\n *     jsonp.request('people.json').subscribe(res => {\n *       this.people = res.json();\n *     })\n *   }\n * }\n * ```\n *\n * The primary public API included in `JSONP_PROVIDERS` is the {@link Jsonp} class.\n * However, other providers required by `Jsonp` are included,\n * which may be beneficial to override in certain cases.\n *\n * The providers included in `JSONP_PROVIDERS` include:\n *  * {@link Jsonp}\n *  * {@link JSONPBackend}\n *  * `BrowserJsonp` - Private factory\n *  * {@link RequestOptions} - Bound to {@link BaseRequestOptions} class\n *  * {@link ResponseOptions} - Bound to {@link BaseResponseOptions} class\n *\n * There may be cases where it makes sense to extend the base request options,\n * such as to add a search string to be appended to all URLs.\n * To accomplish this, a new provider for {@link RequestOptions} should\n * be added in the same injector as `JSONP_PROVIDERS`.\n *\n * ### Example ([live demo](http://plnkr.co/edit/TFug7x?p=preview))\n *\n * ```\n * import {provide} from 'angular2/core';\n * import {bootstrap} from 'angular2/platform/browser';\n * import {JSONP_PROVIDERS, BaseRequestOptions, RequestOptions} from 'angular2/http';\n *\n * class MyOptions extends BaseRequestOptions {\n *   search: string = 'coreTeam=true';\n * }\n *\n * bootstrap(App, [JSONP_PROVIDERS, provide(RequestOptions, {useClass: MyOptions})])\n *   .catch(err => console.error(err));\n * ```\n *\n * Likewise, to use a mock backend for unit tests, the {@link JSONPBackend}\n * provider should be bound to {@link MockBackend}.\n *\n * ### Example ([live demo](http://plnkr.co/edit/HDqZWL?p=preview))\n *\n * ```\n * import {provide, Injector} from 'angular2/core';\n * import {JSONP_PROVIDERS, Jsonp, Response, JSONPBackend} from 'angular2/http';\n * import {MockBackend} from 'angular2/http/testing';\n *\n * var people = [{name: 'Jeff'}, {name: 'Tobias'}];\n * var injector = Injector.resolveAndCreate([\n *   JSONP_PROVIDERS,\n *   MockBackend,\n *   provide(JSONPBackend, {useExisting: MockBackend})\n * ]);\n * var jsonp = injector.get(Jsonp);\n * var backend = injector.get(MockBackend);\n *\n * // Listen for any new requests\n * backend.connections.observer({\n *   next: connection => {\n *     var response = new Response({body: people});\n *     setTimeout(() => {\n *       // Send a response to the request\n *       connection.mockRespond(response);\n *     });\n *   }\n * });\n\n * jsonp.get('people.json').observer({\n *   next: res => {\n *     // Response came from mock backend\n *     console.log('first person', res.json()[0].name);\n *   }\n * });\n * ```\n */\nexport const JSONP_PROVIDERS: any[] = [\n  // TODO(pascal): use factory type annotations once supported in DI\n  // issue: https://github.com/angular/angular/issues/3183\n  provide(Jsonp,\n          {\n            useFactory: (jsonpBackend: JSONPBackend, requestOptions: RequestOptions) =>\n                            new Jsonp(jsonpBackend, requestOptions),\n            deps: [JSONPBackend, RequestOptions]\n          }),\n  BrowserJsonp,\n  provide(RequestOptions, {useClass: BaseRequestOptions}),\n  provide(ResponseOptions, {useClass: BaseResponseOptions}),\n  provide(JSONPBackend, {useClass: JSONPBackend_})\n];\n\n/**\n * See {@link JSONP_PROVIDERS} instead.\n *\n * @deprecated\n */\nexport const JSON_BINDINGS = JSONP_PROVIDERS;\n"]}
|