module.js

/**
 * @fileoverview added by tsickle
 * Generated from: packages/common/http/src/module.ts
 * @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"]}