@angular/common 16.1.0-next.3 → 16.1.0-rc.0

package/esm2022/http/src/fetch.mjs

@@ -0,0 +1,225 @@
+/**
+ * @license
+ * Copyright Google LLC 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 { inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { HttpHeaders } from './headers';
+import { HttpErrorResponse, HttpEventType, HttpHeaderResponse, HttpResponse } from './response';
+import * as i0 from "@angular/core";
+const XSSI_PREFIX = /^\)\]\}',?\n/;
+const REQUEST_URL_HEADER = `X-Request-URL`;
+/**
+ * Determine an appropriate URL for the response, by checking either
+ * response url or the X-Request-URL header.
+ */
+function getResponseUrl(response) {
+    if (response.url) {
+        return response.url;
+    }
+    // stored as lowercase in the map
+    const xRequestUrl = REQUEST_URL_HEADER.toLocaleLowerCase();
+    return response.headers.get(xRequestUrl);
+}
+/**
+ * Uses `fetch` to send requests to a backend server.
+ *
+ * This `FetchBackend` requires the support of the
+ * [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) which is available on all
+ * supported browsers and on Node.js v18 or later.
+ *
+ * @see {@link HttpHandler}
+ *
+ * @publicApi
+ * @developerPreview
+ */
+export class FetchBackend {
+    constructor() {
+        // We need to bind the native fetch to its context or it will throw an "illegal invocation"
+        this.fetchImpl = inject(FetchFactory, { optional: true })?.fetch ?? fetch.bind(globalThis);
+    }
+    handle(request) {
+        return new Observable(observer => {
+            const aborter = new AbortController();
+            this.doRequest(request, aborter.signal, observer)
+                .then(noop, error => observer.error(new HttpErrorResponse({ error })));
+            return () => aborter.abort();
+        });
+    }
+    async doRequest(request, signal, observer) {
+        const init = this.createRequestInit(request);
+        let response;
+        try {
+            const fetchPromise = this.fetchImpl(request.url, { signal, ...init });
+            // Make sure Zone.js doesn't trigger false-positive unhandled promise
+            // error in case the Promise is rejected synchronously. See function
+            // description for additional information.
+            silenceSuperfluousUnhandledPromiseRejection(fetchPromise);
+            // Send the `Sent` event before awaiting the response.
+            observer.next({ type: HttpEventType.Sent });
+            response = await fetchPromise;
+        }
+        catch (error) {
+            observer.error(new HttpErrorResponse({
+                error,
+                status: error.status ?? 0,
+                statusText: error.statusText,
+                url: request.url,
+                headers: error.headers,
+            }));
+            return;
+        }
+        const headers = new HttpHeaders(response.headers);
+        const statusText = response.statusText;
+        const url = getResponseUrl(response) ?? request.url;
+        let status = response.status;
+        let body = null;
+        if (request.reportProgress) {
+            observer.next(new HttpHeaderResponse({ headers, status, statusText, url }));
+        }
+        if (response.body) {
+            // Read Progress
+            const contentLength = response.headers.get('content-length');
+            const chunks = [];
+            const reader = response.body.getReader();
+            let receivedLength = 0;
+            let decoder;
+            let partialText;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                chunks.push(value);
+                receivedLength += value.length;
+                if (request.reportProgress) {
+                    partialText = request.responseType === 'text' ?
+                        (partialText ?? '') + (decoder ??= new TextDecoder).decode(value, { stream: true }) :
+                        undefined;
+                    observer.next({
+                        type: HttpEventType.DownloadProgress,
+                        total: contentLength ? +contentLength : undefined,
+                        loaded: receivedLength,
+                        partialText,
+                    });
+                }
+            }
+            // Combine all chunks.
+            const chunksAll = this.concatChunks(chunks, receivedLength);
+            try {
+                body = this.parseBody(request, chunksAll);
+            }
+            catch (error) {
+                // Body loading or parsing failed
+                observer.error(new HttpErrorResponse({
+                    error,
+                    headers: new HttpHeaders(response.headers),
+                    status: response.status,
+                    statusText: response.statusText,
+                    url: getResponseUrl(response) ?? request.url,
+                }));
+                return;
+            }
+        }
+        // Same behavior as the XhrBackend
+        if (status === 0) {
+            status = body ? 200 /* HttpStatusCode.Ok */ : 0;
+        }
+        // ok determines whether the response will be transmitted on the event or
+        // error channel. Unsuccessful status codes (not 2xx) will always be errors,
+        // but a successful status code can still result in an error if the user
+        // asked for JSON data and the body cannot be parsed as such.
+        const ok = status >= 200 && status < 300;
+        if (ok) {
+            observer.next(new HttpResponse({
+                body,
+                headers,
+                status,
+                statusText,
+                url,
+            }));
+            // The full body has been received and delivered, no further events
+            // are possible. This request is complete.
+            observer.complete();
+        }
+        else {
+            observer.error(new HttpErrorResponse({
+                error: body,
+                headers,
+                status,
+                statusText,
+                url,
+            }));
+        }
+    }
+    parseBody(request, binContent) {
+        switch (request.responseType) {
+            case 'json':
+                // stripping the XSSI when present
+                const text = new TextDecoder().decode(binContent).replace(XSSI_PREFIX, '');
+                return text === '' ? null : JSON.parse(text);
+            case 'text':
+                return new TextDecoder().decode(binContent);
+            case 'blob':
+                return new Blob([binContent]);
+            case 'arraybuffer':
+                return binContent.buffer;
+        }
+    }
+    createRequestInit(req) {
+        // We could share some of this logic with the XhrBackend
+        const headers = {};
+        const credentials = req.withCredentials ? 'include' : undefined;
+        // Setting all the requested headers.
+        req.headers.forEach((name, values) => (headers[name] = values.join(',')));
+        // Add an Accept header if one isn't present already.
+        headers['Accept'] ??= 'application/json, text/plain, */*';
+        // Auto-detect the Content-Type header if one isn't present already.
+        if (!headers['Content-Type']) {
+            const detectedType = req.detectContentTypeHeader();
+            // Sometimes Content-Type detection fails.
+            if (detectedType !== null) {
+                headers['Content-Type'] = detectedType;
+            }
+        }
+        return {
+            body: req.body,
+            method: req.method,
+            headers,
+            credentials,
+        };
+    }
+    concatChunks(chunks, totalLength) {
+        const chunksAll = new Uint8Array(totalLength);
+        let position = 0;
+        for (const chunk of chunks) {
+            chunksAll.set(chunk, position);
+            position += chunk.length;
+        }
+        return chunksAll;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.0-rc.0", ngImport: i0, type: FetchBackend, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.0-rc.0", ngImport: i0, type: FetchBackend }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.0-rc.0", ngImport: i0, type: FetchBackend, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * Abstract class to provide a mocked implementation of `fetch()`
+ */
+export class FetchFactory {
+}
+function noop() { }
+/**
+ * Zone.js treats a rejected promise that has not yet been awaited
+ * as an unhandled error. This function adds a noop `.then` to make
+ * sure that Zone.js doesn't throw an error if the Promise is rejected
+ * synchronously.
+ */
+function silenceSuperfluousUnhandledPromiseRejection(promise) {
+    promise.then(noop, noop);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fetch.js","sourceRoot":"","sources":["../../../../../../../packages/common/http/src/fetch.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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 {inject, Injectable} from '@angular/core';\nimport {Observable, Observer} from 'rxjs';\n\nimport {HttpBackend} from './backend';\nimport {HttpHeaders} from './headers';\nimport {HttpRequest} from './request';\nimport {HttpDownloadProgressEvent, HttpErrorResponse, HttpEvent, HttpEventType, HttpHeaderResponse, HttpResponse, HttpStatusCode} from './response';\n\nconst XSSI_PREFIX = /^\\)\\]\\}',?\\n/;\n\nconst REQUEST_URL_HEADER = `X-Request-URL`;\n\n/**\n * Determine an appropriate URL for the response, by checking either\n * response url or the X-Request-URL header.\n */\nfunction getResponseUrl(response: Response): string|null {\n  if (response.url) {\n    return response.url;\n  }\n  // stored as lowercase in the map\n  const xRequestUrl = REQUEST_URL_HEADER.toLocaleLowerCase();\n  return response.headers.get(xRequestUrl);\n}\n\n/**\n * Uses `fetch` to send requests to a backend server.\n *\n * This `FetchBackend` requires the support of the\n * [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) which is available on all\n * supported browsers and on Node.js v18 or later.\n *\n * @see {@link HttpHandler}\n *\n * @publicApi\n * @developerPreview\n */\n@Injectable()\nexport class FetchBackend implements HttpBackend {\n  // We need to bind the native fetch to its context or it will throw an \"illegal invocation\"\n  private readonly fetchImpl =\n      inject(FetchFactory, {optional: true})?.fetch ?? fetch.bind(globalThis);\n\n  handle(request: HttpRequest<any>): Observable<HttpEvent<any>> {\n    return new Observable(observer => {\n      const aborter = new AbortController();\n      this.doRequest(request, aborter.signal, observer)\n          .then(noop, error => observer.error(new HttpErrorResponse({error})));\n      return () => aborter.abort();\n    });\n  }\n\n  private async doRequest(\n      request: HttpRequest<any>, signal: AbortSignal,\n      observer: Observer<HttpEvent<any>>): Promise<void> {\n    const init = this.createRequestInit(request);\n    let response;\n\n    try {\n      const fetchPromise = this.fetchImpl(request.url, {signal, ...init});\n\n      // Make sure Zone.js doesn't trigger false-positive unhandled promise\n      // error in case the Promise is rejected synchronously. See function\n      // description for additional information.\n      silenceSuperfluousUnhandledPromiseRejection(fetchPromise);\n\n      // Send the `Sent` event before awaiting the response.\n      observer.next({type: HttpEventType.Sent});\n\n      response = await fetchPromise;\n    } catch (error: any) {\n      observer.error(new HttpErrorResponse({\n        error,\n        status: error.status ?? 0,\n        statusText: error.statusText,\n        url: request.url,\n        headers: error.headers,\n      }));\n      return;\n    }\n\n    const headers = new HttpHeaders(response.headers);\n    const statusText = response.statusText;\n    const url = getResponseUrl(response) ?? request.url;\n\n    let status = response.status;\n    let body: string|ArrayBuffer|Blob|object|null = null;\n\n    if (request.reportProgress) {\n      observer.next(new HttpHeaderResponse({headers, status, statusText, url}));\n    }\n\n    if (response.body) {\n      // Read Progress\n      const contentLength = response.headers.get('content-length');\n      const chunks: Uint8Array[] = [];\n      const reader = response.body.getReader();\n      let receivedLength = 0;\n\n      let decoder: TextDecoder;\n      let partialText: string|undefined;\n\n      while (true) {\n        const {done, value} = await reader.read();\n\n        if (done) {\n          break;\n        }\n\n        chunks.push(value);\n        receivedLength += value.length;\n\n        if (request.reportProgress) {\n          partialText = request.responseType === 'text' ?\n              (partialText ?? '') + (decoder ??= new TextDecoder).decode(value, {stream: true}) :\n              undefined;\n\n          observer.next({\n            type: HttpEventType.DownloadProgress,\n            total: contentLength ? +contentLength : undefined,\n            loaded: receivedLength,\n            partialText,\n          } as HttpDownloadProgressEvent);\n        }\n      }\n\n      // Combine all chunks.\n      const chunksAll = this.concatChunks(chunks, receivedLength);\n      try {\n        body = this.parseBody(request, chunksAll);\n      } catch (error) {\n        // Body loading or parsing failed\n        observer.error(new HttpErrorResponse({\n          error,\n          headers: new HttpHeaders(response.headers),\n          status: response.status,\n          statusText: response.statusText,\n          url: getResponseUrl(response) ?? request.url,\n        }));\n        return;\n      }\n    }\n\n    // Same behavior as the XhrBackend\n    if (status === 0) {\n      status = body ? HttpStatusCode.Ok : 0;\n    }\n\n    // ok determines whether the response will be transmitted on the event or\n    // error channel. Unsuccessful status codes (not 2xx) will always be errors,\n    // but a successful status code can still result in an error if the user\n    // asked for JSON data and the body cannot be parsed as such.\n    const ok = status >= 200 && status < 300;\n\n    if (ok) {\n      observer.next(new HttpResponse({\n        body,\n        headers,\n        status,\n        statusText,\n        url,\n      }));\n\n      // The full body has been received and delivered, no further events\n      // are possible. This request is complete.\n      observer.complete();\n    } else {\n      observer.error(new HttpErrorResponse({\n        error: body,\n        headers,\n        status,\n        statusText,\n        url,\n      }));\n    }\n  }\n\n  private parseBody(request: HttpRequest<any>, binContent: Uint8Array): string|ArrayBuffer|Blob\n      |object|null {\n    switch (request.responseType) {\n      case 'json':\n        // stripping the XSSI when present\n        const text = new TextDecoder().decode(binContent).replace(XSSI_PREFIX, '');\n        return text === '' ? null : JSON.parse(text) as object;\n      case 'text':\n        return new TextDecoder().decode(binContent);\n      case 'blob':\n        return new Blob([binContent]);\n      case 'arraybuffer':\n        return binContent.buffer;\n    }\n  }\n\n  private createRequestInit(req: HttpRequest<any>): RequestInit {\n    // We could share some of this logic with the XhrBackend\n\n    const headers: Record<string, string> = {};\n    const credentials: RequestCredentials|undefined = req.withCredentials ? 'include' : undefined;\n\n    // Setting all the requested headers.\n    req.headers.forEach((name, values) => (headers[name] = values.join(',')));\n\n    // Add an Accept header if one isn't present already.\n    headers['Accept'] ??= 'application/json, text/plain, */*';\n\n    // Auto-detect the Content-Type header if one isn't present already.\n    if (!headers['Content-Type']) {\n      const detectedType = req.detectContentTypeHeader();\n      // Sometimes Content-Type detection fails.\n      if (detectedType !== null) {\n        headers['Content-Type'] = detectedType;\n      }\n    }\n\n    return {\n      body: req.body,\n      method: req.method,\n      headers,\n      credentials,\n    };\n  }\n\n  private concatChunks(chunks: Uint8Array[], totalLength: number): Uint8Array {\n    const chunksAll = new Uint8Array(totalLength);\n    let position = 0;\n    for (const chunk of chunks) {\n      chunksAll.set(chunk, position);\n      position += chunk.length;\n    }\n\n    return chunksAll;\n  }\n}\n\n/**\n * Abstract class to provide a mocked implementation of `fetch()`\n */\nexport abstract class FetchFactory {\n  abstract fetch: typeof fetch;\n}\n\nfunction noop(): void {}\n\n/**\n * Zone.js treats a rejected promise that has not yet been awaited\n * as an unhandled error. This function adds a noop `.then` to make\n * sure that Zone.js doesn't throw an error if the Promise is rejected\n * synchronously.\n */\nfunction silenceSuperfluousUnhandledPromiseRejection(promise: Promise<unknown>) {\n  promise.then(noop, noop);\n}\n"]}

package/esm2022/http/src/headers.mjs

@@ -47,6 +47,12 @@ export class HttpHeaders {
                 });
             };
         }
+        else if (typeof Headers !== 'undefined' && headers instanceof Headers) {
+            this.headers = new Map();
+            headers.forEach((values, name) => {
+                this.setHeaderEntries(name, values);
+            });
+        }
         else {
             this.lazyInit = () => {
                 if (typeof ngDevMode === 'undefined' || ngDevMode) {
@@ -54,21 +60,7 @@ export class HttpHeaders {
                 }
                 this.headers = new Map();
                 Object.entries(headers).forEach(([name, values]) => {
-                    let headerValues;
-                    if (typeof values === 'string') {
-                        headerValues = [values];
-                    }
-                    else if (typeof values === 'number') {
-                        headerValues = [values.toString()];
-                    }
-                    else {
-                        headerValues = values.map((value) => value.toString());
-                    }
-                    if (headerValues.length > 0) {
-                        const key = name.toLowerCase();
-                        this.headers.set(key, headerValues);
-                        this.maybeSetNormalizedName(name, key);
-                    }
+                    this.setHeaderEntries(name, values);
                 });
             };
         }
@@ -226,6 +218,12 @@ export class HttpHeaders {
                 break;
         }
     }
+    setHeaderEntries(name, values) {
+        const headerValues = (Array.isArray(values) ? values : [values]).map((value) => value.toString());
+        const key = name.toLowerCase();
+        this.headers.set(key, headerValues);
+        this.maybeSetNormalizedName(name, key);
+    }
     /**
      * @internal
      */
@@ -248,4 +246,4 @@ function assertValidHeaders(headers) {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"headers.js","sourceRoot":"","sources":["../../../../../../../packages/common/http/src/headers.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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\ninterface Update {\n  name: string;\n  value?: string|string[];\n  op: 'a'|'s'|'d';\n}\n\n/**\n * Represents the header configuration options for an HTTP request.\n * Instances are immutable. Modifying methods return a cloned\n * instance with the change. The original object is never changed.\n *\n * @publicApi\n */\nexport class HttpHeaders {\n  /**\n   * Internal map of lowercase header names to values.\n   */\n  // TODO(issue/24571): remove '!'.\n  private headers!: Map<string, string[]>;\n\n\n  /**\n   * Internal map of lowercased header names to the normalized\n   * form of the name (the form seen first).\n   */\n  private normalizedNames: Map<string, string> = new Map();\n\n  /**\n   * Complete the lazy initialization of this object (needed before reading).\n   */\n  private lazyInit!: HttpHeaders|Function|null;\n\n  /**\n   * Queued updates to be materialized the next initialization.\n   */\n  private lazyUpdate: Update[]|null = null;\n\n  /**  Constructs a new HTTP header object with the given values.*/\n\n  constructor(headers?: string|{[name: string]: string | number | (string | number)[]}) {\n    if (!headers) {\n      this.headers = new Map<string, string[]>();\n    } else if (typeof headers === 'string') {\n      this.lazyInit = () => {\n        this.headers = new Map<string, string[]>();\n        headers.split('\\n').forEach(line => {\n          const index = line.indexOf(':');\n          if (index > 0) {\n            const name = line.slice(0, index);\n            const key = name.toLowerCase();\n            const value = line.slice(index + 1).trim();\n            this.maybeSetNormalizedName(name, key);\n            if (this.headers.has(key)) {\n              this.headers.get(key)!.push(value);\n            } else {\n              this.headers.set(key, [value]);\n            }\n          }\n        });\n      };\n    } else {\n      this.lazyInit = () => {\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n          assertValidHeaders(headers);\n        }\n        this.headers = new Map<string, string[]>();\n        Object.entries(headers).forEach(([name, values]) => {\n          let headerValues: string[];\n\n          if (typeof values === 'string') {\n            headerValues = [values];\n          } else if (typeof values === 'number') {\n            headerValues = [values.toString()];\n          } else {\n            headerValues = values.map((value) => value.toString());\n          }\n\n          if (headerValues.length > 0) {\n            const key = name.toLowerCase();\n            this.headers.set(key, headerValues);\n            this.maybeSetNormalizedName(name, key);\n          }\n        });\n      };\n    }\n  }\n\n  /**\n   * Checks for existence of a given header.\n   *\n   * @param name The header name to check for existence.\n   *\n   * @returns True if the header exists, false otherwise.\n   */\n  has(name: string): boolean {\n    this.init();\n\n    return this.headers.has(name.toLowerCase());\n  }\n\n  /**\n   * Retrieves the first value of a given header.\n   *\n   * @param name The header name.\n   *\n   * @returns The value string if the header exists, null otherwise\n   */\n  get(name: string): string|null {\n    this.init();\n\n    const values = this.headers.get(name.toLowerCase());\n    return values && values.length > 0 ? values[0] : null;\n  }\n\n  /**\n   * Retrieves the names of the headers.\n   *\n   * @returns A list of header names.\n   */\n  keys(): string[] {\n    this.init();\n\n    return Array.from(this.normalizedNames.values());\n  }\n\n  /**\n   * Retrieves a list of values for a given header.\n   *\n   * @param name The header name from which to retrieve values.\n   *\n   * @returns A string of values if the header exists, null otherwise.\n   */\n  getAll(name: string): string[]|null {\n    this.init();\n\n    return this.headers.get(name.toLowerCase()) || null;\n  }\n\n  /**\n   * Appends a new value to the existing set of values for a header\n   * and returns them in a clone of the original instance.\n   *\n   * @param name The header name for which to append the values.\n   * @param value The value to append.\n   *\n   * @returns A clone of the HTTP headers object with the value appended to the given header.\n   */\n\n  append(name: string, value: string|string[]): HttpHeaders {\n    return this.clone({name, value, op: 'a'});\n  }\n  /**\n   * Sets or modifies a value for a given header in a clone of the original instance.\n   * If the header already exists, its value is replaced with the given value\n   * in the returned object.\n   *\n   * @param name The header name.\n   * @param value The value or values to set or override for the given header.\n   *\n   * @returns A clone of the HTTP headers object with the newly set header value.\n   */\n  set(name: string, value: string|string[]): HttpHeaders {\n    return this.clone({name, value, op: 's'});\n  }\n  /**\n   * Deletes values for a given header in a clone of the original instance.\n   *\n   * @param name The header name.\n   * @param value The value or values to delete for the given header.\n   *\n   * @returns A clone of the HTTP headers object with the given value deleted.\n   */\n  delete(name: string, value?: string|string[]): HttpHeaders {\n    return this.clone({name, value, op: 'd'});\n  }\n\n  private maybeSetNormalizedName(name: string, lcName: string): void {\n    if (!this.normalizedNames.has(lcName)) {\n      this.normalizedNames.set(lcName, name);\n    }\n  }\n\n  private init(): void {\n    if (!!this.lazyInit) {\n      if (this.lazyInit instanceof HttpHeaders) {\n        this.copyFrom(this.lazyInit);\n      } else {\n        this.lazyInit();\n      }\n      this.lazyInit = null;\n      if (!!this.lazyUpdate) {\n        this.lazyUpdate.forEach(update => this.applyUpdate(update));\n        this.lazyUpdate = null;\n      }\n    }\n  }\n\n  private copyFrom(other: HttpHeaders) {\n    other.init();\n    Array.from(other.headers.keys()).forEach(key => {\n      this.headers.set(key, other.headers.get(key)!);\n      this.normalizedNames.set(key, other.normalizedNames.get(key)!);\n    });\n  }\n\n  private clone(update: Update): HttpHeaders {\n    const clone = new HttpHeaders();\n    clone.lazyInit =\n        (!!this.lazyInit && this.lazyInit instanceof HttpHeaders) ? this.lazyInit : this;\n    clone.lazyUpdate = (this.lazyUpdate || []).concat([update]);\n    return clone;\n  }\n\n  private applyUpdate(update: Update): void {\n    const key = update.name.toLowerCase();\n    switch (update.op) {\n      case 'a':\n      case 's':\n        let value = update.value!;\n        if (typeof value === 'string') {\n          value = [value];\n        }\n        if (value.length === 0) {\n          return;\n        }\n        this.maybeSetNormalizedName(update.name, key);\n        const base = (update.op === 'a' ? this.headers.get(key) : undefined) || [];\n        base.push(...value);\n        this.headers.set(key, base);\n        break;\n      case 'd':\n        const toDelete = update.value as string | undefined;\n        if (!toDelete) {\n          this.headers.delete(key);\n          this.normalizedNames.delete(key);\n        } else {\n          let existing = this.headers.get(key);\n          if (!existing) {\n            return;\n          }\n          existing = existing.filter(value => toDelete.indexOf(value) === -1);\n          if (existing.length === 0) {\n            this.headers.delete(key);\n            this.normalizedNames.delete(key);\n          } else {\n            this.headers.set(key, existing);\n          }\n        }\n        break;\n    }\n  }\n\n  /**\n   * @internal\n   */\n  forEach(fn: (name: string, values: string[]) => void) {\n    this.init();\n    Array.from(this.normalizedNames.keys())\n        .forEach(key => fn(this.normalizedNames.get(key)!, this.headers.get(key)!));\n  }\n}\n\n/**\n * Verifies that the headers object has the right shape: the values\n * must be either strings, numbers or arrays. Throws an error if an invalid\n * header value is present.\n */\nfunction assertValidHeaders(headers: Record<string, unknown>):\n    asserts headers is Record<string, string|string[]|number|number[]> {\n  for (const [key, value] of Object.entries(headers)) {\n    if (!(typeof value === 'string' || typeof value === 'number') && !Array.isArray(value)) {\n      throw new Error(\n          `Unexpected value of the \\`${key}\\` header provided. ` +\n          `Expecting either a string, a number or an array, but got: \\`${value}\\`.`);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"headers.js","sourceRoot":"","sources":["../../../../../../../packages/common/http/src/headers.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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\ninterface Update {\n  name: string;\n  value?: string|string[];\n  op: 'a'|'s'|'d';\n}\n\n/**\n * Represents the header configuration options for an HTTP request.\n * Instances are immutable. Modifying methods return a cloned\n * instance with the change. The original object is never changed.\n *\n * @publicApi\n */\nexport class HttpHeaders {\n  /**\n   * Internal map of lowercase header names to values.\n   */\n  // TODO(issue/24571): remove '!'.\n  private headers!: Map<string, string[]>;\n\n\n  /**\n   * Internal map of lowercased header names to the normalized\n   * form of the name (the form seen first).\n   */\n  private normalizedNames: Map<string, string> = new Map();\n\n  /**\n   * Complete the lazy initialization of this object (needed before reading).\n   */\n  private lazyInit!: HttpHeaders|Function|null;\n\n  /**\n   * Queued updates to be materialized the next initialization.\n   */\n  private lazyUpdate: Update[]|null = null;\n\n  /**  Constructs a new HTTP header object with the given values.*/\n\n  constructor(headers?: string|{[name: string]: string | number | (string | number)[]}|Headers) {\n    if (!headers) {\n      this.headers = new Map<string, string[]>();\n    } else if (typeof headers === 'string') {\n      this.lazyInit = () => {\n        this.headers = new Map<string, string[]>();\n        headers.split('\\n').forEach(line => {\n          const index = line.indexOf(':');\n          if (index > 0) {\n            const name = line.slice(0, index);\n            const key = name.toLowerCase();\n            const value = line.slice(index + 1).trim();\n            this.maybeSetNormalizedName(name, key);\n            if (this.headers.has(key)) {\n              this.headers.get(key)!.push(value);\n            } else {\n              this.headers.set(key, [value]);\n            }\n          }\n        });\n      };\n    } else if (typeof Headers !== 'undefined' && headers instanceof Headers) {\n      this.headers = new Map<string, string[]>();\n      headers.forEach((values: string, name: string) => {\n        this.setHeaderEntries(name, values);\n      });\n    } else {\n      this.lazyInit = () => {\n        if (typeof ngDevMode === 'undefined' || ngDevMode) {\n          assertValidHeaders(headers);\n        }\n        this.headers = new Map<string, string[]>();\n        Object.entries(headers).forEach(([name, values]) => {\n          this.setHeaderEntries(name, values);\n        });\n      };\n    }\n  }\n\n  /**\n   * Checks for existence of a given header.\n   *\n   * @param name The header name to check for existence.\n   *\n   * @returns True if the header exists, false otherwise.\n   */\n  has(name: string): boolean {\n    this.init();\n\n    return this.headers.has(name.toLowerCase());\n  }\n\n  /**\n   * Retrieves the first value of a given header.\n   *\n   * @param name The header name.\n   *\n   * @returns The value string if the header exists, null otherwise\n   */\n  get(name: string): string|null {\n    this.init();\n\n    const values = this.headers.get(name.toLowerCase());\n    return values && values.length > 0 ? values[0] : null;\n  }\n\n  /**\n   * Retrieves the names of the headers.\n   *\n   * @returns A list of header names.\n   */\n  keys(): string[] {\n    this.init();\n\n    return Array.from(this.normalizedNames.values());\n  }\n\n  /**\n   * Retrieves a list of values for a given header.\n   *\n   * @param name The header name from which to retrieve values.\n   *\n   * @returns A string of values if the header exists, null otherwise.\n   */\n  getAll(name: string): string[]|null {\n    this.init();\n\n    return this.headers.get(name.toLowerCase()) || null;\n  }\n\n  /**\n   * Appends a new value to the existing set of values for a header\n   * and returns them in a clone of the original instance.\n   *\n   * @param name The header name for which to append the values.\n   * @param value The value to append.\n   *\n   * @returns A clone of the HTTP headers object with the value appended to the given header.\n   */\n\n  append(name: string, value: string|string[]): HttpHeaders {\n    return this.clone({name, value, op: 'a'});\n  }\n  /**\n   * Sets or modifies a value for a given header in a clone of the original instance.\n   * If the header already exists, its value is replaced with the given value\n   * in the returned object.\n   *\n   * @param name The header name.\n   * @param value The value or values to set or override for the given header.\n   *\n   * @returns A clone of the HTTP headers object with the newly set header value.\n   */\n  set(name: string, value: string|string[]): HttpHeaders {\n    return this.clone({name, value, op: 's'});\n  }\n  /**\n   * Deletes values for a given header in a clone of the original instance.\n   *\n   * @param name The header name.\n   * @param value The value or values to delete for the given header.\n   *\n   * @returns A clone of the HTTP headers object with the given value deleted.\n   */\n  delete(name: string, value?: string|string[]): HttpHeaders {\n    return this.clone({name, value, op: 'd'});\n  }\n\n  private maybeSetNormalizedName(name: string, lcName: string): void {\n    if (!this.normalizedNames.has(lcName)) {\n      this.normalizedNames.set(lcName, name);\n    }\n  }\n\n  private init(): void {\n    if (!!this.lazyInit) {\n      if (this.lazyInit instanceof HttpHeaders) {\n        this.copyFrom(this.lazyInit);\n      } else {\n        this.lazyInit();\n      }\n      this.lazyInit = null;\n      if (!!this.lazyUpdate) {\n        this.lazyUpdate.forEach(update => this.applyUpdate(update));\n        this.lazyUpdate = null;\n      }\n    }\n  }\n\n  private copyFrom(other: HttpHeaders) {\n    other.init();\n    Array.from(other.headers.keys()).forEach(key => {\n      this.headers.set(key, other.headers.get(key)!);\n      this.normalizedNames.set(key, other.normalizedNames.get(key)!);\n    });\n  }\n\n  private clone(update: Update): HttpHeaders {\n    const clone = new HttpHeaders();\n    clone.lazyInit =\n        (!!this.lazyInit && this.lazyInit instanceof HttpHeaders) ? this.lazyInit : this;\n    clone.lazyUpdate = (this.lazyUpdate || []).concat([update]);\n    return clone;\n  }\n\n  private applyUpdate(update: Update): void {\n    const key = update.name.toLowerCase();\n    switch (update.op) {\n      case 'a':\n      case 's':\n        let value = update.value!;\n        if (typeof value === 'string') {\n          value = [value];\n        }\n        if (value.length === 0) {\n          return;\n        }\n        this.maybeSetNormalizedName(update.name, key);\n        const base = (update.op === 'a' ? this.headers.get(key) : undefined) || [];\n        base.push(...value);\n        this.headers.set(key, base);\n        break;\n      case 'd':\n        const toDelete = update.value as string | undefined;\n        if (!toDelete) {\n          this.headers.delete(key);\n          this.normalizedNames.delete(key);\n        } else {\n          let existing = this.headers.get(key);\n          if (!existing) {\n            return;\n          }\n          existing = existing.filter(value => toDelete.indexOf(value) === -1);\n          if (existing.length === 0) {\n            this.headers.delete(key);\n            this.normalizedNames.delete(key);\n          } else {\n            this.headers.set(key, existing);\n          }\n        }\n        break;\n    }\n  }\n\n  private setHeaderEntries(name: string, values: any) {\n    const headerValues =\n        (Array.isArray(values) ? values : [values]).map((value) => value.toString());\n    const key = name.toLowerCase();\n    this.headers.set(key, headerValues);\n    this.maybeSetNormalizedName(name, key);\n  }\n\n  /**\n   * @internal\n   */\n  forEach(fn: (name: string, values: string[]) => void) {\n    this.init();\n    Array.from(this.normalizedNames.keys())\n        .forEach(key => fn(this.normalizedNames.get(key)!, this.headers.get(key)!));\n  }\n}\n\n/**\n * Verifies that the headers object has the right shape: the values\n * must be either strings, numbers or arrays. Throws an error if an invalid\n * header value is present.\n */\nfunction assertValidHeaders(headers: Record<string, unknown>|Headers):\n    asserts headers is Record<string, string|string[]|number|number[]> {\n  for (const [key, value] of Object.entries(headers)) {\n    if (!(typeof value === 'string' || typeof value === 'number') && !Array.isArray(value)) {\n      throw new Error(\n          `Unexpected value of the \\`${key}\\` header provided. ` +\n          `Expecting either a string, a number or an array, but got: \\`${value}\\`.`);\n    }\n  }\n}\n"]}

package/esm2022/http/src/interceptor.mjs

@@ -66,7 +66,7 @@ export function legacyInterceptorFnFactory() {
         return chain(req, handler).pipe(finalize(() => pendingTasks.remove(taskId)));
     };
 }
-class HttpInterceptorHandler extends HttpHandler {
+export class HttpInterceptorHandler extends HttpHandler {
     constructor(backend, injector) {
         super();
         this.backend = backend;
@@ -90,11 +90,10 @@ class HttpInterceptorHandler extends HttpHandler {
         return this.chain(initialRequest, downstreamRequest => this.backend.handle(downstreamRequest))
             .pipe(finalize(() => this.pendingTasks.remove(taskId)));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.0-next.3", ngImport: i0, type: HttpInterceptorHandler, deps: [{ token: i1.HttpBackend }, { token: i0.EnvironmentInjector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.0-next.3", ngImport: i0, type: HttpInterceptorHandler }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.0-rc.0", ngImport: i0, type: HttpInterceptorHandler, deps: [{ token: i1.HttpBackend }, { token: i0.EnvironmentInjector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.0-rc.0", ngImport: i0, type: HttpInterceptorHandler }); }
 }
-export { HttpInterceptorHandler };
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.0-next.3", ngImport: i0, type: HttpInterceptorHandler, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.0-rc.0", ngImport: i0, type: HttpInterceptorHandler, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i1.HttpBackend }, { type: i0.EnvironmentInjector }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../../../../../../packages/common/http/src/interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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 {EnvironmentInjector, inject, Injectable, InjectionToken, ɵInitialRenderPendingTasks as InitialRenderPendingTasks} from '@angular/core';\nimport {Observable} from 'rxjs';\nimport {finalize} from 'rxjs/operators';\n\nimport {HttpBackend, HttpHandler} from './backend';\nimport {HttpRequest} from './request';\nimport {HttpEvent} from './response';\n\n/**\n * Intercepts and handles an `HttpRequest` or `HttpResponse`.\n *\n * Most interceptors transform the outgoing request before passing it to the\n * next interceptor in the chain, by calling `next.handle(transformedReq)`.\n * An interceptor may transform the\n * response event stream as well, by applying additional RxJS operators on the stream\n * returned by `next.handle()`.\n *\n * More rarely, an interceptor may handle the request entirely,\n * and compose a new event stream instead of invoking `next.handle()`. This is an\n * acceptable behavior, but keep in mind that further interceptors will be skipped entirely.\n *\n * It is also rare but valid for an interceptor to return multiple responses on the\n * event stream for a single request.\n *\n * @publicApi\n *\n * @see [HTTP Guide](guide/http#intercepting-requests-and-responses)\n *\n * @usageNotes\n *\n * To use the same instance of `HttpInterceptors` for the entire app, import the `HttpClientModule`\n * only in your `AppModule`, and add the interceptors to the root application injector.\n * If you import `HttpClientModule` multiple times across different modules (for example, in lazy\n * loading modules), each import creates a new copy of the `HttpClientModule`, which overwrites the\n * interceptors provided in the root module.\n */\nexport interface HttpInterceptor {\n  /**\n   * Identifies and handles a given HTTP request.\n   * @param req The outgoing request object to handle.\n   * @param next The next interceptor in the chain, or the backend\n   * if no interceptors remain in the chain.\n   * @returns An observable of the event stream.\n   */\n  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;\n}\n\n/**\n * Represents the next interceptor in an interceptor chain, or the real backend if there are no\n * further interceptors.\n *\n * Most interceptors will delegate to this function, and either modify the outgoing request or the\n * response when it arrives. Within the scope of the current request, however, this function may be\n * called any number of times, for any number of downstream requests. Such downstream requests need\n * not be to the same URL or even the same origin as the current request. It is also valid to not\n * call the downstream handler at all, and process the current request entirely within the\n * interceptor.\n *\n * This function should only be called within the scope of the request that's currently being\n * intercepted. Once that request is complete, this downstream handler function should not be\n * called.\n *\n * @publicApi\n *\n * @see [HTTP Guide](guide/http#intercepting-requests-and-responses)\n */\nexport type HttpHandlerFn = (req: HttpRequest<unknown>) => Observable<HttpEvent<unknown>>;\n\n/**\n * An interceptor for HTTP requests made via `HttpClient`.\n *\n * `HttpInterceptorFn`s are middleware functions which `HttpClient` calls when a request is made.\n * These functions have the opportunity to modify the outgoing request or any response that comes\n * back, as well as block, redirect, or otherwise change the request or response semantics.\n *\n * An `HttpHandlerFn` representing the next interceptor (or the backend which will make a real HTTP\n * request) is provided. Most interceptors will delegate to this function, but that is not required\n * (see `HttpHandlerFn` for more details).\n *\n * `HttpInterceptorFn`s have access to `inject()` via the `EnvironmentInjector` from which they were\n * configured.\n */\nexport type HttpInterceptorFn = (req: HttpRequest<unknown>, next: HttpHandlerFn) =>\n    Observable<HttpEvent<unknown>>;\n\n/**\n * Function which invokes an HTTP interceptor chain.\n *\n * Each interceptor in the interceptor chain is turned into a `ChainedInterceptorFn` which closes\n * over the rest of the chain (represented by another `ChainedInterceptorFn`). The last such\n * function in the chain will instead delegate to the `finalHandlerFn`, which is passed down when\n * the chain is invoked.\n *\n * This pattern allows for a chain of many interceptors to be composed and wrapped in a single\n * `HttpInterceptorFn`, which is a useful abstraction for including different kinds of interceptors\n * (e.g. legacy class-based interceptors) in the same chain.\n */\ntype ChainedInterceptorFn<RequestT> = (req: HttpRequest<RequestT>, finalHandlerFn: HttpHandlerFn) =>\n    Observable<HttpEvent<RequestT>>;\n\nfunction interceptorChainEndFn(\n    req: HttpRequest<any>, finalHandlerFn: HttpHandlerFn): Observable<HttpEvent<any>> {\n  return finalHandlerFn(req);\n}\n\n/**\n * Constructs a `ChainedInterceptorFn` which adapts a legacy `HttpInterceptor` to the\n * `ChainedInterceptorFn` interface.\n */\nfunction adaptLegacyInterceptorToChain(\n    chainTailFn: ChainedInterceptorFn<any>,\n    interceptor: HttpInterceptor): ChainedInterceptorFn<any> {\n  return (initialRequest, finalHandlerFn) => interceptor.intercept(initialRequest, {\n    handle: (downstreamRequest) => chainTailFn(downstreamRequest, finalHandlerFn),\n  });\n}\n\n/**\n * Constructs a `ChainedInterceptorFn` which wraps and invokes a functional interceptor in the given\n * injector.\n */\nfunction chainedInterceptorFn(\n    chainTailFn: ChainedInterceptorFn<unknown>, interceptorFn: HttpInterceptorFn,\n    injector: EnvironmentInjector): ChainedInterceptorFn<unknown> {\n  // clang-format off\n  return (initialRequest, finalHandlerFn) => injector.runInContext(() =>\n    interceptorFn(\n      initialRequest,\n      downstreamRequest => chainTailFn(downstreamRequest, finalHandlerFn)\n    )\n  );\n  // clang-format on\n}\n\n/**\n * A multi-provider token that represents the array of registered\n * `HttpInterceptor` objects.\n *\n * @publicApi\n */\nexport const HTTP_INTERCEPTORS =\n    new InjectionToken<HttpInterceptor[]>(ngDevMode ? 'HTTP_INTERCEPTORS' : '');\n\n/**\n * A multi-provided token of `HttpInterceptorFn`s.\n */\nexport const HTTP_INTERCEPTOR_FNS =\n    new InjectionToken<HttpInterceptorFn[]>(ngDevMode ? 'HTTP_INTERCEPTOR_FNS' : '');\n\n/**\n * A multi-provided token of `HttpInterceptorFn`s that are only set in root.\n */\nexport const HTTP_ROOT_INTERCEPTOR_FNS =\n    new InjectionToken<HttpInterceptorFn[]>(ngDevMode ? 'HTTP_ROOT_INTERCEPTOR_FNS' : '');\n\n/**\n * Creates an `HttpInterceptorFn` which lazily initializes an interceptor chain from the legacy\n * class-based interceptors and runs the request through it.\n */\nexport function legacyInterceptorFnFactory(): HttpInterceptorFn {\n  let chain: ChainedInterceptorFn<any>|null = null;\n\n  return (req, handler) => {\n    if (chain === null) {\n      const interceptors = inject(HTTP_INTERCEPTORS, {optional: true}) ?? [];\n      // Note: interceptors are wrapped right-to-left so that final execution order is\n      // left-to-right. That is, if `interceptors` is the array `[a, b, c]`, we want to\n      // produce a chain that is conceptually `c(b(a(end)))`, which we build from the inside\n      // out.\n      chain = interceptors.reduceRight(\n          adaptLegacyInterceptorToChain, interceptorChainEndFn as ChainedInterceptorFn<any>);\n    }\n\n    const pendingTasks = inject(InitialRenderPendingTasks);\n    const taskId = pendingTasks.add();\n    return chain(req, handler).pipe(finalize(() => pendingTasks.remove(taskId)));\n  };\n}\n\n@Injectable()\nexport class HttpInterceptorHandler extends HttpHandler {\n  private chain: ChainedInterceptorFn<unknown>|null = null;\n  private readonly pendingTasks = inject(InitialRenderPendingTasks);\n\n  constructor(private backend: HttpBackend, private injector: EnvironmentInjector) {\n    super();\n  }\n\n  override handle(initialRequest: HttpRequest<any>): Observable<HttpEvent<any>> {\n    if (this.chain === null) {\n      const dedupedInterceptorFns = Array.from(new Set([\n        ...this.injector.get(HTTP_INTERCEPTOR_FNS),\n        ...this.injector.get(HTTP_ROOT_INTERCEPTOR_FNS, []),\n      ]));\n\n      // Note: interceptors are wrapped right-to-left so that final execution order is\n      // left-to-right. That is, if `dedupedInterceptorFns` is the array `[a, b, c]`, we want to\n      // produce a chain that is conceptually `c(b(a(end)))`, which we build from the inside\n      // out.\n      this.chain = dedupedInterceptorFns.reduceRight(\n          (nextSequencedFn, interceptorFn) =>\n              chainedInterceptorFn(nextSequencedFn, interceptorFn, this.injector),\n          interceptorChainEndFn as ChainedInterceptorFn<unknown>);\n    }\n\n    const taskId = this.pendingTasks.add();\n    return this.chain(initialRequest, downstreamRequest => this.backend.handle(downstreamRequest))\n        .pipe(finalize(() => this.pendingTasks.remove(taskId)));\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../../../../../../packages/common/http/src/interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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 {EnvironmentInjector, inject, Injectable, InjectionToken, ɵInitialRenderPendingTasks as InitialRenderPendingTasks} from '@angular/core';\nimport {Observable} from 'rxjs';\nimport {finalize} from 'rxjs/operators';\n\nimport {HttpBackend, HttpHandler} from './backend';\nimport {HttpRequest} from './request';\nimport {HttpEvent} from './response';\n\n/**\n * Intercepts and handles an `HttpRequest` or `HttpResponse`.\n *\n * Most interceptors transform the outgoing request before passing it to the\n * next interceptor in the chain, by calling `next.handle(transformedReq)`.\n * An interceptor may transform the\n * response event stream as well, by applying additional RxJS operators on the stream\n * returned by `next.handle()`.\n *\n * More rarely, an interceptor may handle the request entirely,\n * and compose a new event stream instead of invoking `next.handle()`. This is an\n * acceptable behavior, but keep in mind that further interceptors will be skipped entirely.\n *\n * It is also rare but valid for an interceptor to return multiple responses on the\n * event stream for a single request.\n *\n * @publicApi\n *\n * @see [HTTP Guide](guide/http#intercepting-requests-and-responses)\n *\n * @usageNotes\n *\n * To use the same instance of `HttpInterceptors` for the entire app, import the `HttpClientModule`\n * only in your `AppModule`, and add the interceptors to the root application injector.\n * If you import `HttpClientModule` multiple times across different modules (for example, in lazy\n * loading modules), each import creates a new copy of the `HttpClientModule`, which overwrites the\n * interceptors provided in the root module.\n */\nexport interface HttpInterceptor {\n  /**\n   * Identifies and handles a given HTTP request.\n   * @param req The outgoing request object to handle.\n   * @param next The next interceptor in the chain, or the backend\n   * if no interceptors remain in the chain.\n   * @returns An observable of the event stream.\n   */\n  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;\n}\n\n/**\n * Represents the next interceptor in an interceptor chain, or the real backend if there are no\n * further interceptors.\n *\n * Most interceptors will delegate to this function, and either modify the outgoing request or the\n * response when it arrives. Within the scope of the current request, however, this function may be\n * called any number of times, for any number of downstream requests. Such downstream requests need\n * not be to the same URL or even the same origin as the current request. It is also valid to not\n * call the downstream handler at all, and process the current request entirely within the\n * interceptor.\n *\n * This function should only be called within the scope of the request that's currently being\n * intercepted. Once that request is complete, this downstream handler function should not be\n * called.\n *\n * @publicApi\n *\n * @see [HTTP Guide](guide/http#intercepting-requests-and-responses)\n */\nexport type HttpHandlerFn = (req: HttpRequest<unknown>) => Observable<HttpEvent<unknown>>;\n\n/**\n * An interceptor for HTTP requests made via `HttpClient`.\n *\n * `HttpInterceptorFn`s are middleware functions which `HttpClient` calls when a request is made.\n * These functions have the opportunity to modify the outgoing request or any response that comes\n * back, as well as block, redirect, or otherwise change the request or response semantics.\n *\n * An `HttpHandlerFn` representing the next interceptor (or the backend which will make a real HTTP\n * request) is provided. Most interceptors will delegate to this function, but that is not required\n * (see `HttpHandlerFn` for more details).\n *\n * `HttpInterceptorFn`s have access to `inject()` via the `EnvironmentInjector` from which they were\n * configured.\n */\nexport type HttpInterceptorFn = (req: HttpRequest<unknown>, next: HttpHandlerFn) =>\n    Observable<HttpEvent<unknown>>;\n\n/**\n * Function which invokes an HTTP interceptor chain.\n *\n * Each interceptor in the interceptor chain is turned into a `ChainedInterceptorFn` which closes\n * over the rest of the chain (represented by another `ChainedInterceptorFn`). The last such\n * function in the chain will instead delegate to the `finalHandlerFn`, which is passed down when\n * the chain is invoked.\n *\n * This pattern allows for a chain of many interceptors to be composed and wrapped in a single\n * `HttpInterceptorFn`, which is a useful abstraction for including different kinds of interceptors\n * (e.g. legacy class-based interceptors) in the same chain.\n */\ntype ChainedInterceptorFn<RequestT> = (req: HttpRequest<RequestT>, finalHandlerFn: HttpHandlerFn) =>\n    Observable<HttpEvent<RequestT>>;\n\nfunction interceptorChainEndFn(\n    req: HttpRequest<any>, finalHandlerFn: HttpHandlerFn): Observable<HttpEvent<any>> {\n  return finalHandlerFn(req);\n}\n\n/**\n * Constructs a `ChainedInterceptorFn` which adapts a legacy `HttpInterceptor` to the\n * `ChainedInterceptorFn` interface.\n */\nfunction adaptLegacyInterceptorToChain(\n    chainTailFn: ChainedInterceptorFn<any>,\n    interceptor: HttpInterceptor): ChainedInterceptorFn<any> {\n  return (initialRequest, finalHandlerFn) => interceptor.intercept(initialRequest, {\n    handle: (downstreamRequest) => chainTailFn(downstreamRequest, finalHandlerFn),\n  });\n}\n\n/**\n * Constructs a `ChainedInterceptorFn` which wraps and invokes a functional interceptor in the given\n * injector.\n */\nfunction chainedInterceptorFn(\n    chainTailFn: ChainedInterceptorFn<unknown>, interceptorFn: HttpInterceptorFn,\n    injector: EnvironmentInjector): ChainedInterceptorFn<unknown> {\n  // clang-format off\n  return (initialRequest, finalHandlerFn) => injector.runInContext(() =>\n    interceptorFn(\n      initialRequest,\n      downstreamRequest => chainTailFn(downstreamRequest, finalHandlerFn)\n    )\n  );\n  // clang-format on\n}\n\n/**\n * A multi-provider token that represents the array of registered\n * `HttpInterceptor` objects.\n *\n * @publicApi\n */\nexport const HTTP_INTERCEPTORS =\n    new InjectionToken<HttpInterceptor[]>(ngDevMode ? 'HTTP_INTERCEPTORS' : '');\n\n/**\n * A multi-provided token of `HttpInterceptorFn`s.\n */\nexport const HTTP_INTERCEPTOR_FNS =\n    new InjectionToken<HttpInterceptorFn[]>(ngDevMode ? 'HTTP_INTERCEPTOR_FNS' : '');\n\n/**\n * A multi-provided token of `HttpInterceptorFn`s that are only set in root.\n */\nexport const HTTP_ROOT_INTERCEPTOR_FNS =\n    new InjectionToken<HttpInterceptorFn[]>(ngDevMode ? 'HTTP_ROOT_INTERCEPTOR_FNS' : '');\n\n/**\n * Creates an `HttpInterceptorFn` which lazily initializes an interceptor chain from the legacy\n * class-based interceptors and runs the request through it.\n */\nexport function legacyInterceptorFnFactory(): HttpInterceptorFn {\n  let chain: ChainedInterceptorFn<any>|null = null;\n\n  return (req, handler) => {\n    if (chain === null) {\n      const interceptors = inject(HTTP_INTERCEPTORS, {optional: true}) ?? [];\n      // Note: interceptors are wrapped right-to-left so that final execution order is\n      // left-to-right. That is, if `interceptors` is the array `[a, b, c]`, we want to\n      // produce a chain that is conceptually `c(b(a(end)))`, which we build from the inside\n      // out.\n      chain = interceptors.reduceRight(\n          adaptLegacyInterceptorToChain, interceptorChainEndFn as ChainedInterceptorFn<any>);\n    }\n\n    const pendingTasks = inject(InitialRenderPendingTasks);\n    const taskId = pendingTasks.add();\n    return chain(req, handler).pipe(finalize(() => pendingTasks.remove(taskId)));\n  };\n}\n\n@Injectable()\nexport class HttpInterceptorHandler extends HttpHandler {\n  private chain: ChainedInterceptorFn<unknown>|null = null;\n  private readonly pendingTasks = inject(InitialRenderPendingTasks);\n\n  constructor(private backend: HttpBackend, private injector: EnvironmentInjector) {\n    super();\n  }\n\n  override handle(initialRequest: HttpRequest<any>): Observable<HttpEvent<any>> {\n    if (this.chain === null) {\n      const dedupedInterceptorFns = Array.from(new Set([\n        ...this.injector.get(HTTP_INTERCEPTOR_FNS),\n        ...this.injector.get(HTTP_ROOT_INTERCEPTOR_FNS, []),\n      ]));\n\n      // Note: interceptors are wrapped right-to-left so that final execution order is\n      // left-to-right. That is, if `dedupedInterceptorFns` is the array `[a, b, c]`, we want to\n      // produce a chain that is conceptually `c(b(a(end)))`, which we build from the inside\n      // out.\n      this.chain = dedupedInterceptorFns.reduceRight(\n          (nextSequencedFn, interceptorFn) =>\n              chainedInterceptorFn(nextSequencedFn, interceptorFn, this.injector),\n          interceptorChainEndFn as ChainedInterceptorFn<unknown>);\n    }\n\n    const taskId = this.pendingTasks.add();\n    return this.chain(initialRequest, downstreamRequest => this.backend.handle(downstreamRequest))\n        .pipe(finalize(() => this.pendingTasks.remove(taskId)));\n  }\n}\n"]}