@angular/common
Version:
Angular - commonly needed directives and services
231 lines • 19.9 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,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, Injector, NgModule } from '@angular/core';
import { HttpBackend, HttpHandler } from './backend';
import { HttpClient } from './client';
import { HTTP_INTERCEPTORS, HttpInterceptorHandler, NoopInterceptor } from './interceptor';
import { JsonpCallbackContext, JsonpClientBackend, JsonpInterceptor } from './jsonp';
import { BrowserXhr, HttpXhrBackend, XhrFactory } from './xhr';
import { HttpXsrfCookieExtractor, HttpXsrfInterceptor, HttpXsrfTokenExtractor, XSRF_COOKIE_NAME, XSRF_HEADER_NAME } from './xsrf';
/**
* An injectable `HttpHandler` that applies multiple interceptors
* to a request before passing it to the given `HttpBackend`.
*
* The interceptors are loaded lazily from the injector, to allow
* interceptors to themselves inject classes depending indirectly
* on `HttpInterceptingHandler` itself.
* @see `HttpInterceptor`
*/
export class HttpInterceptingHandler {
/**
* @param {?} backend
* @param {?} injector
*/
constructor(backend, injector) {
this.backend = backend;
this.injector = injector;
this.chain = null;
}
/**
* @param {?} req
* @return {?}
*/
handle(req) {
if (this.chain === null) {
/** @type {?} */
const interceptors = this.injector.get(HTTP_INTERCEPTORS, []);
this.chain = interceptors.reduceRight((/**
* @param {?} next
* @param {?} interceptor
* @return {?}
*/
(next, interceptor) => new HttpInterceptorHandler(next, interceptor)), this.backend);
}
return this.chain.handle(req);
}
}
HttpInterceptingHandler.decorators = [
{ type: Injectable }
];
/** @nocollapse */
HttpInterceptingHandler.ctorParameters = () => [
{ type: HttpBackend },
{ type: Injector }
];
if (false) {
/**
* @type {?}
* @private
*/
HttpInterceptingHandler.prototype.chain;
/**
* @type {?}
* @private
*/
HttpInterceptingHandler.prototype.backend;
/**
* @type {?}
* @private
*/
HttpInterceptingHandler.prototype.injector;
}
/**
* Constructs an `HttpHandler` that applies interceptors
* to a request before passing it to the given `HttpBackend`.
*
* Use as a factory function within `HttpClientModule`.
*
*
* @param {?} backend
* @param {?=} interceptors
* @return {?}
*/
export function interceptingHandler(backend, interceptors = []) {
if (!interceptors) {
return backend;
}
return interceptors.reduceRight((/**
* @param {?} next
* @param {?} interceptor
* @return {?}
*/
(next, interceptor) => new HttpInterceptorHandler(next, interceptor)), backend);
}
/**
* Factory function that determines where to store JSONP callbacks.
*
* Ordinarily JSONP callbacks are stored on the `window` object, but this may not exist
* in test environments. In that case, callbacks are stored on an anonymous object instead.
*
*
* @return {?}
*/
export function jsonpCallbackContext() {
if (typeof window === 'object') {
return window;
}
return {};
}
/**
* Configures XSRF protection support for outgoing requests.
*
* For a server that supports a cookie-based XSRF protection system,
* use directly to configure XSRF protection with the correct
* cookie and header names.
*
* If no names are supplied, the default cookie name is `XSRF-TOKEN`
* and the default header name is `X-XSRF-TOKEN`.
*
* \@publicApi
*/
export class HttpClientXsrfModule {
/**
* Disable the default XSRF protection.
* @return {?}
*/
static disable() {
return {
ngModule: HttpClientXsrfModule,
providers: [
{ provide: HttpXsrfInterceptor, useClass: NoopInterceptor },
],
};
}
/**
* Configure XSRF protection.
* @param {?=} options An object that can specify either or both
* cookie name or header name.
* - Cookie name default is `XSRF-TOKEN`.
* - Header name default is `X-XSRF-TOKEN`.
*
* @return {?}
*/
static withOptions(options = {}) {
return {
ngModule: HttpClientXsrfModule,
providers: [
options.cookieName ? { provide: XSRF_COOKIE_NAME, useValue: options.cookieName } : [],
options.headerName ? { provide: XSRF_HEADER_NAME, useValue: options.headerName } : [],
],
};
}
}
HttpClientXsrfModule.decorators = [
{ type: NgModule, args: [{
providers: [
HttpXsrfInterceptor,
{ provide: HTTP_INTERCEPTORS, useExisting: HttpXsrfInterceptor, multi: true },
{ provide: HttpXsrfTokenExtractor, useClass: HttpXsrfCookieExtractor },
{ provide: XSRF_COOKIE_NAME, useValue: 'XSRF-TOKEN' },
{ provide: XSRF_HEADER_NAME, useValue: 'X-XSRF-TOKEN' },
],
},] }
];
/**
* Configures the [dependency injector](guide/glossary#injector) for `HttpClient`
* with supporting services for XSRF. Automatically imported by `HttpClientModule`.
*
* You can add interceptors to the chain behind `HttpClient` by binding them to the
* multiprovider for built-in [DI token](guide/glossary#di-token) `HTTP_INTERCEPTORS`.
*
* \@publicApi
*/
export class HttpClientModule {
}
HttpClientModule.decorators = [
{ type: NgModule, args: [{
/**
* Optional configuration for XSRF protection.
*/
imports: [
HttpClientXsrfModule.withOptions({
cookieName: 'XSRF-TOKEN',
headerName: 'X-XSRF-TOKEN',
}),
],
/**
* Configures the [dependency injector](guide/glossary#injector) where it is imported
* with supporting services for HTTP communications.
*/
providers: [
HttpClient,
{ provide: HttpHandler, useClass: HttpInterceptingHandler },
HttpXhrBackend,
{ provide: HttpBackend, useExisting: HttpXhrBackend },
BrowserXhr,
{ provide: XhrFactory, useExisting: BrowserXhr },
],
},] }
];
/**
* Configures the [dependency injector](guide/glossary#injector) for `HttpClient`
* with supporting services for JSONP.
* Without this module, Jsonp requests reach the backend
* with method JSONP, where they are rejected.
*
* You can add interceptors to the chain behind `HttpClient` by binding them to the
* multiprovider for built-in [DI token](guide/glossary#di-token) `HTTP_INTERCEPTORS`.
*
* \@publicApi
*/
export class HttpClientJsonpModule {
}
HttpClientJsonpModule.decorators = [
{ type: NgModule, args: [{
providers: [
JsonpClientBackend,
{ provide: JsonpCallbackContext, useFactory: jsonpCallbackContext },
{ provide: HTTP_INTERCEPTORS, useClass: JsonpInterceptor, multi: true },
],
},] }
];
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../../../packages/common/http/src/module.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, Injector, ModuleWithProviders, NgModule} from '@angular/core';\nimport {Observable} from 'rxjs';\n\nimport {HttpBackend, HttpHandler} from './backend';\nimport {HttpClient} from './client';\nimport {HTTP_INTERCEPTORS, HttpInterceptor, HttpInterceptorHandler, NoopInterceptor} from './interceptor';\nimport {JsonpCallbackContext, JsonpClientBackend, JsonpInterceptor} from './jsonp';\nimport {HttpRequest} from './request';\nimport {HttpEvent} from './response';\nimport {BrowserXhr, HttpXhrBackend, XhrFactory} from './xhr';\nimport {HttpXsrfCookieExtractor, HttpXsrfInterceptor, HttpXsrfTokenExtractor, XSRF_COOKIE_NAME, XSRF_HEADER_NAME} from './xsrf';\n\n/**\n * An injectable `HttpHandler` that applies multiple interceptors\n * to a request before passing it to the given `HttpBackend`.\n *\n * The interceptors are loaded lazily from the injector, to allow\n * interceptors to themselves inject classes depending indirectly\n * on `HttpInterceptingHandler` itself.\n * @see `HttpInterceptor`\n */\n@Injectable()\nexport class HttpInterceptingHandler implements HttpHandler {\n  private chain: HttpHandler|null = null;\n\n  constructor(private backend: HttpBackend, private injector: Injector) {}\n\n  handle(req: HttpRequest<any>): Observable<HttpEvent<any>> {\n    if (this.chain === null) {\n      const interceptors = this.injector.get(HTTP_INTERCEPTORS, []);\n      this.chain = interceptors.reduceRight(\n          (next, interceptor) => new HttpInterceptorHandler(next, interceptor), this.backend);\n    }\n    return this.chain.handle(req);\n  }\n}\n\n/**\n * Constructs an `HttpHandler` that applies interceptors\n * to a request before passing it to the given `HttpBackend`.\n *\n * Use as a factory function within `HttpClientModule`.\n *\n *\n */\nexport function interceptingHandler(\n    backend: HttpBackend, interceptors: HttpInterceptor[] | null = []): HttpHandler {\n  if (!interceptors) {\n    return backend;\n  }\n  return interceptors.reduceRight(\n      (next, interceptor) => new HttpInterceptorHandler(next, interceptor), backend);\n}\n\n/**\n * Factory function that determines where to store JSONP callbacks.\n *\n * Ordinarily JSONP callbacks are stored on the `window` object, but this may not exist\n * in test environments. In that case, callbacks are stored on an anonymous object instead.\n *\n *\n */\nexport function jsonpCallbackContext(): Object {\n  if (typeof window === 'object') {\n    return window;\n  }\n  return {};\n}\n\n/**\n * Configures XSRF protection support for outgoing requests.\n *\n * For a server that supports a cookie-based XSRF protection system,\n * use directly to configure XSRF protection with the correct\n * cookie and header names.\n *\n * If no names are supplied, the default cookie name is `XSRF-TOKEN`\n * and the default header name is `X-XSRF-TOKEN`.\n *\n * @publicApi\n */\n@NgModule({\n  providers: [\n    HttpXsrfInterceptor,\n    {provide: HTTP_INTERCEPTORS, useExisting: HttpXsrfInterceptor, multi: true},\n    {provide: HttpXsrfTokenExtractor, useClass: HttpXsrfCookieExtractor},\n    {provide: XSRF_COOKIE_NAME, useValue: 'XSRF-TOKEN'},\n    {provide: XSRF_HEADER_NAME, useValue: 'X-XSRF-TOKEN'},\n  ],\n})\nexport class HttpClientXsrfModule {\n  /**\n   * Disable the default XSRF protection.\n   */\n  static disable(): ModuleWithProviders<HttpClientXsrfModule> {\n    return {\n      ngModule: HttpClientXsrfModule,\n      providers: [\n        {provide: HttpXsrfInterceptor, useClass: NoopInterceptor},\n      ],\n    };\n  }\n\n  /**\n   * Configure XSRF protection.\n   * @param options An object that can specify either or both\n   * cookie name or header name.\n   * - Cookie name default is `XSRF-TOKEN`.\n   * - Header name default is `X-XSRF-TOKEN`.\n   *\n   */\n  static withOptions(options: {\n    cookieName?: string,\n    headerName?: string,\n  } = {}): ModuleWithProviders<HttpClientXsrfModule> {\n    return {\n      ngModule: HttpClientXsrfModule,\n      providers: [\n        options.cookieName ? {provide: XSRF_COOKIE_NAME, useValue: options.cookieName} : [],\n        options.headerName ? {provide: XSRF_HEADER_NAME, useValue: options.headerName} : [],\n      ],\n    };\n  }\n}\n\n/**\n * Configures the [dependency injector](guide/glossary#injector) for `HttpClient`\n * with supporting services for XSRF. Automatically imported by `HttpClientModule`.\n *\n * You can add interceptors to the chain behind `HttpClient` by binding them to the\n * multiprovider for built-in [DI token](guide/glossary#di-token) `HTTP_INTERCEPTORS`.\n *\n * @publicApi\n */\n@NgModule({\n  /**\n   * Optional configuration for XSRF protection.\n   */\n  imports: [\n    HttpClientXsrfModule.withOptions({\n      cookieName: 'XSRF-TOKEN',\n      headerName: 'X-XSRF-TOKEN',\n    }),\n  ],\n  /**\n   * Configures the [dependency injector](guide/glossary#injector) where it is imported\n   * with supporting services for HTTP communications.\n   */\n  providers: [\n    HttpClient,\n    {provide: HttpHandler, useClass: HttpInterceptingHandler},\n    HttpXhrBackend,\n    {provide: HttpBackend, useExisting: HttpXhrBackend},\n    BrowserXhr,\n    {provide: XhrFactory, useExisting: BrowserXhr},\n  ],\n})\nexport class HttpClientModule {\n}\n\n/**\n * Configures the [dependency injector](guide/glossary#injector) for `HttpClient`\n * with supporting services for JSONP.\n * Without this module, Jsonp requests reach the backend\n * with method JSONP, where they are rejected.\n *\n * You can add interceptors to the chain behind `HttpClient` by binding them to the\n * multiprovider for built-in [DI token](guide/glossary#di-token) `HTTP_INTERCEPTORS`.\n *\n * @publicApi\n */\n@NgModule({\n  providers: [\n    JsonpClientBackend,\n    {provide: JsonpCallbackContext, useFactory: jsonpCallbackContext},\n    {provide: HTTP_INTERCEPTORS, useClass: JsonpInterceptor, multi: true},\n  ],\n})\nexport class HttpClientJsonpModule {\n}\n"]}