package.esm2022.http.src.fetch.mjs Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of common Show documentation
Show all versions of common Show documentation
Angular - commonly needed directives and services
/**
* @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.dev/license
*/
import { inject, Injectable, NgZone } from '@angular/core';
import { Observable } from 'rxjs';
import { HttpHeaders } from './headers';
import { HTTP_STATUS_CODE_OK, 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
*/
export class FetchBackend {
constructor() {
// We use an arrow function to always reference the current global implementation of `fetch`.
// This is helpful for cases when the global `fetch` implementation is modified by external code,
// see https://github.com/angular/angular/issues/57527.
this.fetchImpl = inject(FetchFactory, { optional: true })?.fetch ?? ((...args) => globalThis.fetch(...args));
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 {
// Run fetch outside of Angular zone.
// This is due to Node.js fetch implementation (Undici) which uses a number of setTimeouts to check if
// the response should eventually timeout which causes extra CD cycles every 500ms
const fetchPromise = this.ngZone.runOutsideAngular(() => 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 {
const contentType = response.headers.get('Content-Type') ?? '';
body = this.parseBody(request, chunksAll, contentType);
}
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 ? HTTP_STATUS_CODE_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, contentType) {
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], { type: contentType });
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.
if (!req.headers.has('Accept')) {
headers['Accept'] = 'application/json, text/plain, */*';
}
// Auto-detect the Content-Type header if one isn't present already.
if (!req.headers.has('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: "18.2.6", ngImport: i0, type: FetchBackend, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: FetchBackend }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.6", 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":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAC,MAAM,eAAe,CAAC;AACzD,OAAO,EAAC,UAAU,EAAW,MAAM,MAAM,CAAC;AAG1C,OAAO,EAAC,WAAW,EAAC,MAAM,WAAW,CAAC;AAEtC,OAAO,EACL,mBAAmB,EAEnB,iBAAiB,EAEjB,aAAa,EACb,kBAAkB,EAClB,YAAY,GACb,MAAM,YAAY,CAAC;;AAEpB,MAAM,WAAW,GAAG,cAAc,CAAC;AAEnC,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAE3C;;;GAGG;AACH,SAAS,cAAc,CAAC,QAAkB;IACxC,IAAI,QAAQ,CAAC,GAAG,EAAE,CAAC;QACjB,OAAO,QAAQ,CAAC,GAAG,CAAC;IACtB,CAAC;IACD,iCAAiC;IACjC,MAAM,WAAW,GAAG,kBAAkB,CAAC,iBAAiB,EAAE,CAAC;IAC3D,OAAO,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;AAC3C,CAAC;AAED;;;;;;;;;;GAUG;AAEH,MAAM,OAAO,YAAY;IADzB;QAEE,6FAA6F;QAC7F,iGAAiG;QACjG,uDAAuD;QACtC,cAAS,GACxB,MAAM,CAAC,YAAY,EAAE,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC,GAAG,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;QAC3E,WAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;KAkO1C;IAhOC,MAAM,CAAC,OAAyB;QAC9B,OAAO,IAAI,UAAU,CAAC,CAAC,QAAQ,EAAE,EAAE;YACjC,MAAM,OAAO,GAAG,IAAI,eAAe,EAAE,CAAC;YACtC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,CACrE,QAAQ,CAAC,KAAK,CAAC,IAAI,iBAAiB,CAAC,EAAC,KAAK,EAAC,CAAC,CAAC,CAC/C,CAAC;YACF,OAAO,GAAG,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QAC/B,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,SAAS,CACrB,OAAyB,EACzB,MAAmB,EACnB,QAAkC;QAElC,MAAM,IAAI,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAC7C,IAAI,QAAQ,CAAC;QAEb,IAAI,CAAC;YACH,qCAAqC;YACrC,sGAAsG;YACtG,kFAAkF;YAClF,MAAM,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,GAAG,EAAE,CACtD,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,aAAa,EAAE,EAAC,MAAM,EAAE,GAAG,IAAI,EAAC,CAAC,CACzD,CAAC;YAEF,qEAAqE;YACrE,oEAAoE;YACpE,0CAA0C;YAC1C,2CAA2C,CAAC,YAAY,CAAC,CAAC;YAE1D,sDAAsD;YACtD,QAAQ,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,aAAa,CAAC,IAAI,EAAC,CAAC,CAAC;YAE1C,QAAQ,GAAG,MAAM,YAAY,CAAC;QAChC,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,QAAQ,CAAC,KAAK,CACZ,IAAI,iBAAiB,CAAC;gBACpB,KAAK;gBACL,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC;gBACzB,UAAU,EAAE,KAAK,CAAC,UAAU;gBAC5B,GAAG,EAAE,OAAO,CAAC,aAAa;gBAC1B,OAAO,EAAE,KAAK,CAAC,OAAO;aACvB,CAAC,CACH,CAAC;YACF,OAAO;QACT,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAClD,MAAM,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC;QACvC,MAAM,GAAG,GAAG,cAAc,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,aAAa,CAAC;QAE9D,IAAI,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;QAC7B,IAAI,IAAI,GAAgD,IAAI,CAAC;QAE7D,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;YAC3B,QAAQ,CAAC,IAAI,CAAC,IAAI,kBAAkB,CAAC,EAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,EAAC,CAAC,CAAC,CAAC;QAC5E,CAAC;QAED,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC;YAClB,gBAAgB;YAChB,MAAM,aAAa,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;YAC7D,MAAM,MAAM,GAAiB,EAAE,CAAC;YAChC,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACzC,IAAI,cAAc,GAAG,CAAC,CAAC;YAEvB,IAAI,OAAoB,CAAC;YACzB,IAAI,WAA+B,CAAC;YAEpC,8FAA8F;YAC9F,2BAA2B;YAC3B,MAAM,OAAO,GAAG,OAAO,IAAI,KAAK,WAAW,IAAI,IAAI,CAAC,OAAO,CAAC;YAE5D,yDAAyD;YACzD,yDAAyD;YACzD,6FAA6F;YAC7F,MAAM,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,KAAK,IAAI,EAAE;gBAC7C,OAAO,IAAI,EAAE,CAAC;oBACZ,MAAM,EAAC,IAAI,EAAE,KAAK,EAAC,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;oBAE1C,IAAI,IAAI,EAAE,CAAC;wBACT,MAAM;oBACR,CAAC;oBAED,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBACnB,cAAc,IAAI,KAAK,CAAC,MAAM,CAAC;oBAE/B,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;wBAC3B,WAAW;4BACT,OAAO,CAAC,YAAY,KAAK,MAAM;gCAC7B,CAAC,CAAC,CAAC,WAAW,IAAI,EAAE,CAAC;oCACnB,CAAC,OAAO,KAAK,IAAI,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC;gCAC/D,CAAC,CAAC,SAAS,CAAC;wBAEhB,MAAM,cAAc,GAAG,GAAG,EAAE,CAC1B,QAAQ,CAAC,IAAI,CAAC;4BACZ,IAAI,EAAE,aAAa,CAAC,gBAAgB;4BACpC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS;4BACjD,MAAM,EAAE,cAAc;4BACtB,WAAW;yBACiB,CAAC,CAAC;wBAClC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,cAAc,EAAE,CAAC;oBAC3D,CAAC;gBACH,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,sBAAsB;YACtB,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;YAC5D,IAAI,CAAC;gBACH,MAAM,WAAW,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC;gBAC/D,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC;YACzD,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,iCAAiC;gBACjC,QAAQ,CAAC,KAAK,CACZ,IAAI,iBAAiB,CAAC;oBACpB,KAAK;oBACL,OAAO,EAAE,IAAI,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC;oBAC1C,MAAM,EAAE,QAAQ,CAAC,MAAM;oBACvB,UAAU,EAAE,QAAQ,CAAC,UAAU;oBAC/B,GAAG,EAAE,cAAc,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,aAAa;iBACvD,CAAC,CACH,CAAC;gBACF,OAAO;YACT,CAAC;QACH,CAAC;QAED,kCAAkC;QAClC,IAAI,MAAM,KAAK,CAAC,EAAE,CAAC;YACjB,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1C,CAAC;QAED,yEAAyE;QACzE,4EAA4E;QAC5E,wEAAwE;QACxE,6DAA6D;QAC7D,MAAM,EAAE,GAAG,MAAM,IAAI,GAAG,IAAI,MAAM,GAAG,GAAG,CAAC;QAEzC,IAAI,EAAE,EAAE,CAAC;YACP,QAAQ,CAAC,IAAI,CACX,IAAI,YAAY,CAAC;gBACf,IAAI;gBACJ,OAAO;gBACP,MAAM;gBACN,UAAU;gBACV,GAAG;aACJ,CAAC,CACH,CAAC;YAEF,mEAAmE;YACnE,0CAA0C;YAC1C,QAAQ,CAAC,QAAQ,EAAE,CAAC;QACtB,CAAC;aAAM,CAAC;YACN,QAAQ,CAAC,KAAK,CACZ,IAAI,iBAAiB,CAAC;gBACpB,KAAK,EAAE,IAAI;gBACX,OAAO;gBACP,MAAM;gBACN,UAAU;gBACV,GAAG;aACJ,CAAC,CACH,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,SAAS,CACf,OAAyB,EACzB,UAAsB,EACtB,WAAmB;QAEnB,QAAQ,OAAO,CAAC,YAAY,EAAE,CAAC;YAC7B,KAAK,MAAM;gBACT,kCAAkC;gBAClC,MAAM,IAAI,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;gBAC3E,OAAO,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAY,CAAC;YAC3D,KAAK,MAAM;gBACT,OAAO,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;YAC9C,KAAK,MAAM;gBACT,OAAO,IAAI,IAAI,CAAC,CAAC,UAAU,CAAC,EAAE,EAAC,IAAI,EAAE,WAAW,EAAC,CAAC,CAAC;YACrD,KAAK,aAAa;gBAChB,OAAO,UAAU,CAAC,MAAM,CAAC;QAC7B,CAAC;IACH,CAAC;IAEO,iBAAiB,CAAC,GAAqB;QAC7C,wDAAwD;QAExD,MAAM,OAAO,GAA2B,EAAE,CAAC;QAC3C,MAAM,WAAW,GAAmC,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;QAEhG,qCAAqC;QACrC,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAE1E,qDAAqD;QACrD,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC/B,OAAO,CAAC,QAAQ,CAAC,GAAG,mCAAmC,CAAC;QAC1D,CAAC;QAED,oEAAoE;QACpE,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE,CAAC;YACrC,MAAM,YAAY,GAAG,GAAG,CAAC,uBAAuB,EAAE,CAAC;YACnD,0CAA0C;YAC1C,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;gBAC1B,OAAO,CAAC,cAAc,CAAC,GAAG,YAAY,CAAC;YACzC,CAAC;QACH,CAAC;QAED,OAAO;YACL,IAAI,EAAE,GAAG,CAAC,aAAa,EAAE;YACzB,MAAM,EAAE,GAAG,CAAC,MAAM;YAClB,OAAO;YACP,WAAW;SACZ,CAAC;IACJ,CAAC;IAEO,YAAY,CAAC,MAAoB,EAAE,WAAmB;QAC5D,MAAM,SAAS,GAAG,IAAI,UAAU,CAAC,WAAW,CAAC,CAAC;QAC9C,IAAI,QAAQ,GAAG,CAAC,CAAC;QACjB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,SAAS,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;YAC/B,QAAQ,IAAI,KAAK,CAAC,MAAM,CAAC;QAC3B,CAAC;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;yHAvOU,YAAY;6HAAZ,YAAY;;sGAAZ,YAAY;kBADxB,UAAU;;AA2OX;;GAEG;AACH,MAAM,OAAgB,YAAY;CAEjC;AAED,SAAS,IAAI,KAAU,CAAC;AAExB;;;;;GAKG;AACH,SAAS,2CAA2C,CAAC,OAAyB;IAC5E,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAC3B,CAAC","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.dev/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 {\n  HTTP_STATUS_CODE_OK,\n  HttpDownloadProgressEvent,\n  HttpErrorResponse,\n  HttpEvent,\n  HttpEventType,\n  HttpHeaderResponse,\n  HttpResponse,\n} 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 */\n@Injectable()\nexport class FetchBackend implements HttpBackend {\n  // We use an arrow function to always reference the current global implementation of `fetch`.\n  // This is helpful for cases when the global `fetch` implementation is modified by external code,\n  // see https://github.com/angular/angular/issues/57527.\n  private readonly fetchImpl =\n    inject(FetchFactory, {optional: true})?.fetch ?? ((...args) => globalThis.fetch(...args));\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).then(noop, (error) =>\n        observer.error(new HttpErrorResponse({error})),\n      );\n      return () => aborter.abort();\n    });\n  }\n\n  private async doRequest(\n    request: HttpRequest<any>,\n    signal: AbortSignal,\n    observer: Observer<HttpEvent<any>>,\n  ): Promise<void> {\n    const init = this.createRequestInit(request);\n    let response;\n\n    try {\n      // Run fetch outside of Angular zone.\n      // This is due to Node.js fetch implementation (Undici) which uses a number of setTimeouts to check if\n      // the response should eventually timeout which causes extra CD cycles every 500ms\n      const fetchPromise = this.ngZone.runOutsideAngular(() =>\n        this.fetchImpl(request.urlWithParams, {signal, ...init}),\n      );\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(\n        new HttpErrorResponse({\n          error,\n          status: error.status ?? 0,\n          statusText: error.statusText,\n          url: request.urlWithParams,\n          headers: error.headers,\n        }),\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 =\n              request.responseType === 'text'\n                ? (partialText ?? '') +\n                  (decoder ??= new TextDecoder()).decode(value, {stream: true})\n                : undefined;\n\n            const reportProgress = () =>\n              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        const contentType = response.headers.get('Content-Type') ?? '';\n        body = this.parseBody(request, chunksAll, contentType);\n      } catch (error) {\n        // Body loading or parsing failed\n        observer.error(\n          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        );\n        return;\n      }\n    }\n\n    // Same behavior as the XhrBackend\n    if (status === 0) {\n      status = body ? HTTP_STATUS_CODE_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(\n        new HttpResponse({\n          body,\n          headers,\n          status,\n          statusText,\n          url,\n        }),\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(\n        new HttpErrorResponse({\n          error: body,\n          headers,\n          status,\n          statusText,\n          url,\n        }),\n      );\n    }\n  }\n\n  private parseBody(\n    request: HttpRequest<any>,\n    binContent: Uint8Array,\n    contentType: string,\n  ): string | ArrayBuffer | Blob | 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], {type: contentType});\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    if (!req.headers.has('Accept')) {\n      headers['Accept'] = 'application/json, text/plain, */*';\n    }\n\n    // Auto-detect the Content-Type header if one isn't present already.\n    if (!req.headers.has('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"]}