@angular/common
Version:
Angular - commonly needed directives and services
235 lines • 30.1 kB
JavaScript
/**
* @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, NgZone } 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);
this.ngZone = inject(NgZone);
}
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.urlWithParams, { 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.urlWithParams,
headers: error.headers,
}));
return;
}
const headers = new HttpHeaders(response.headers);
const statusText = response.statusText;
const url = getResponseUrl(response) ?? request.urlWithParams;
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;
// We have to check whether the Zone is defined in the global scope because this may be called
// when the zone is nooped.
const reqZone = typeof Zone !== 'undefined' && Zone.current;
// Perform response processing outside of Angular zone to
// ensure no excessive change detection runs are executed
// Here calling the async ReadableStreamDefaultReader.read() is responsible for triggering CD
await this.ngZone.runOutsideAngular(async () => {
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;
const reportProgress = () => observer.next({
type: HttpEventType.DownloadProgress,
total: contentLength ? +contentLength : undefined,
loaded: receivedLength,
partialText,
});
reqZone ? reqZone.run(reportProgress) : reportProgress();
}
}
});
// 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.urlWithParams,
}));
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.serializeBody(),
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.2.11", ngImport: i0, type: FetchBackend, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.11", ngImport: i0, type: FetchBackend }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.11", 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, NgZone} 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  private readonly ngZone = inject(NgZone);\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.urlWithParams, {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.urlWithParams,\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.urlWithParams;\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      // We have to check whether the Zone is defined in the global scope because this may be called\n      // when the zone is nooped.\n      const reqZone = typeof Zone !== 'undefined' && Zone.current;\n\n      // Perform response processing outside of Angular zone to\n      // ensure no excessive change detection runs are executed\n      // Here calling the async ReadableStreamDefaultReader.read() is responsible for triggering CD\n      await this.ngZone.runOutsideAngular(async () => {\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            const reportProgress = () => observer.next({\n              type: HttpEventType.DownloadProgress,\n              total: contentLength ? +contentLength : undefined,\n              loaded: receivedLength,\n              partialText,\n            } as HttpDownloadProgressEvent);\n            reqZone ? reqZone.run(reportProgress) : reportProgress();\n          }\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.urlWithParams,\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.serializeBody(),\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"]}