File: /var/www/vhost/disk-apps/pwa.sports-crowd.com/node_modules/@angular/common/esm2022/http/src/xhr.mjs
/**
* @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 { XhrFactory } from '@angular/common';
import { Injectable, ɵRuntimeError as RuntimeError } from '@angular/core';
import { from, Observable, of } from 'rxjs';
import { switchMap } from 'rxjs/operators';
import { HttpHeaders } from './headers';
import { HttpErrorResponse, HttpEventType, HttpHeaderResponse, HttpResponse } from './response';
import * as i0 from "@angular/core";
import * as i1 from "@angular/common";
const XSSI_PREFIX = /^\)\]\}',?\n/;
/**
* Determine an appropriate URL for the response, by checking either
* XMLHttpRequest.responseURL or the X-Request-URL header.
*/
function getResponseUrl(xhr) {
if ('responseURL' in xhr && xhr.responseURL) {
return xhr.responseURL;
}
if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {
return xhr.getResponseHeader('X-Request-URL');
}
return null;
}
/**
* Uses `XMLHttpRequest` to send requests to a backend server.
* @see {@link HttpHandler}
* @see {@link JsonpClientBackend}
*
* @publicApi
*/
export class HttpXhrBackend {
constructor(xhrFactory) {
this.xhrFactory = xhrFactory;
}
/**
* Processes a request and returns a stream of response events.
* @param req The request object.
* @returns An observable of the response events.
*/
handle(req) {
// Quick check to give a better error message when a user attempts to use
// HttpClient.jsonp() without installing the HttpClientJsonpModule
if (req.method === 'JSONP') {
throw new RuntimeError(-2800 /* RuntimeErrorCode.MISSING_JSONP_MODULE */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
`Cannot make a JSONP request without JSONP support. To fix the problem, either add the \`withJsonpSupport()\` call (if \`provideHttpClient()\` is used) or import the \`HttpClientJsonpModule\` in the root NgModule.`);
}
// Check whether this factory has a special function to load an XHR implementation
// for various non-browser environments. We currently limit it to only `ServerXhr`
// class, which needs to load an XHR implementation.
const xhrFactory = this.xhrFactory;
const source = xhrFactory.ɵloadImpl ? from(xhrFactory.ɵloadImpl()) : of(null);
return source.pipe(switchMap(() => {
// Everything happens on Observable subscription.
return new Observable((observer) => {
// Start by setting up the XHR object with request method, URL, and withCredentials
// flag.
const xhr = xhrFactory.build();
xhr.open(req.method, req.urlWithParams);
if (req.withCredentials) {
xhr.withCredentials = true;
}
// Add all the requested headers.
req.headers.forEach((name, values) => xhr.setRequestHeader(name, values.join(',')));
// Add an Accept header if one isn't present already.
if (!req.headers.has('Accept')) {
xhr.setRequestHeader('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) {
xhr.setRequestHeader('Content-Type', detectedType);
}
}
// Set the responseType if one was requested.
if (req.responseType) {
const responseType = req.responseType.toLowerCase();
// JSON responses need to be processed as text. This is because if the server
// returns an XSSI-prefixed JSON response, the browser will fail to parse it,
// xhr.response will be null, and xhr.responseText cannot be accessed to
// retrieve the prefixed JSON data in order to strip the prefix. Thus, all JSON
// is parsed by first requesting text and then applying JSON.parse.
xhr.responseType = ((responseType !== 'json') ? responseType : 'text');
}
// Serialize the request body if one is present. If not, this will be set to null.
const reqBody = req.serializeBody();
// If progress events are enabled, response headers will be delivered
// in two events - the HttpHeaderResponse event and the full HttpResponse
// event. However, since response headers don't change in between these
// two events, it doesn't make sense to parse them twice. So headerResponse
// caches the data extracted from the response whenever it's first parsed,
// to ensure parsing isn't duplicated.
let headerResponse = null;
// partialFromXhr extracts the HttpHeaderResponse from the current XMLHttpRequest
// state, and memoizes it into headerResponse.
const partialFromXhr = () => {
if (headerResponse !== null) {
return headerResponse;
}
const statusText = xhr.statusText || 'OK';
// Parse headers from XMLHttpRequest - this step is lazy.
const headers = new HttpHeaders(xhr.getAllResponseHeaders());
// Read the response URL from the XMLHttpResponse instance and fall back on the
// request URL.
const url = getResponseUrl(xhr) || req.url;
// Construct the HttpHeaderResponse and memoize it.
headerResponse =
new HttpHeaderResponse({ headers, status: xhr.status, statusText, url });
return headerResponse;
};
// Next, a few closures are defined for the various events which XMLHttpRequest can
// emit. This allows them to be unregistered as event listeners later.
// First up is the load event, which represents a response being fully available.
const onLoad = () => {
// Read response state from the memoized partial data.
let { headers, status, statusText, url } = partialFromXhr();
// The body will be read out if present.
let body = null;
if (status !== 204 /* HttpStatusCode.NoContent */) {
// Use XMLHttpRequest.response if set, responseText otherwise.
body = (typeof xhr.response === 'undefined') ? xhr.responseText : xhr.response;
}
// Normalize another potential bug (this one comes from CORS).
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.
let ok = status >= 200 && status < 300;
// Check whether the body needs to be parsed as JSON (in many cases the browser
// will have done that already).
if (req.responseType === 'json' && typeof body === 'string') {
// Save the original body, before attempting XSSI prefix stripping.
const originalBody = body;
body = body.replace(XSSI_PREFIX, '');
try {
// Attempt the parse. If it fails, a parse error should be delivered to the
// user.
body = body !== '' ? JSON.parse(body) : null;
}
catch (error) {
// Since the JSON.parse failed, it's reasonable to assume this might not have
// been a JSON response. Restore the original body (including any XSSI prefix)
// to deliver a better error response.
body = originalBody;
// If this was an error request to begin with, leave it as a string, it
// probably just isn't JSON. Otherwise, deliver the parsing error to the user.
if (ok) {
// Even though the response status was 2xx, this is still an error.
ok = false;
// The parse error contains the text of the body that failed to parse.
body = { error, text: body };
}
}
}
if (ok) {
// A successful response is delivered on the event stream.
observer.next(new HttpResponse({
body,
headers,
status,
statusText,
url: url || undefined,
}));
// The full body has been received and delivered, no further events
// are possible. This request is complete.
observer.complete();
}
else {
// An unsuccessful request is delivered on the error channel.
observer.error(new HttpErrorResponse({
// The error in this case is the response body (error from the server).
error: body,
headers,
status,
statusText,
url: url || undefined,
}));
}
};
// The onError callback is called when something goes wrong at the network level.
// Connection timeout, DNS error, offline, etc. These are actual errors, and are
// transmitted on the error channel.
const onError = (error) => {
const { url } = partialFromXhr();
const res = new HttpErrorResponse({
error,
status: xhr.status || 0,
statusText: xhr.statusText || 'Unknown Error',
url: url || undefined,
});
observer.error(res);
};
// The sentHeaders flag tracks whether the HttpResponseHeaders event
// has been sent on the stream. This is necessary to track if progress
// is enabled since the event will be sent on only the first download
// progress event.
let sentHeaders = false;
// The download progress event handler, which is only registered if
// progress events are enabled.
const onDownProgress = (event) => {
// Send the HttpResponseHeaders event if it hasn't been sent already.
if (!sentHeaders) {
observer.next(partialFromXhr());
sentHeaders = true;
}
// Start building the download progress event to deliver on the response
// event stream.
let progressEvent = {
type: HttpEventType.DownloadProgress,
loaded: event.loaded,
};
// Set the total number of bytes in the event if it's available.
if (event.lengthComputable) {
progressEvent.total = event.total;
}
// If the request was for text content and a partial response is
// available on XMLHttpRequest, include it in the progress event
// to allow for streaming reads.
if (req.responseType === 'text' && !!xhr.responseText) {
progressEvent.partialText = xhr.responseText;
}
// Finally, fire the event.
observer.next(progressEvent);
};
// The upload progress event handler, which is only registered if
// progress events are enabled.
const onUpProgress = (event) => {
// Upload progress events are simpler. Begin building the progress
// event.
let progress = {
type: HttpEventType.UploadProgress,
loaded: event.loaded,
};
// If the total number of bytes being uploaded is available, include
// it.
if (event.lengthComputable) {
progress.total = event.total;
}
// Send the event.
observer.next(progress);
};
// By default, register for load and error events.
xhr.addEventListener('load', onLoad);
xhr.addEventListener('error', onError);
xhr.addEventListener('timeout', onError);
xhr.addEventListener('abort', onError);
// Progress events are only enabled if requested.
if (req.reportProgress) {
// Download progress is always enabled if requested.
xhr.addEventListener('progress', onDownProgress);
// Upload progress depends on whether there is a body to upload.
if (reqBody !== null && xhr.upload) {
xhr.upload.addEventListener('progress', onUpProgress);
}
}
// Fire the request, and notify the event stream that it was fired.
xhr.send(reqBody);
observer.next({ type: HttpEventType.Sent });
// This is the return from the Observable function, which is the
// request cancellation handler.
return () => {
// On a cancellation, remove all registered event listeners.
xhr.removeEventListener('error', onError);
xhr.removeEventListener('abort', onError);
xhr.removeEventListener('load', onLoad);
xhr.removeEventListener('timeout', onError);
if (req.reportProgress) {
xhr.removeEventListener('progress', onDownProgress);
if (reqBody !== null && xhr.upload) {
xhr.upload.removeEventListener('progress', onUpProgress);
}
}
// Finally, abort the in-flight request.
if (xhr.readyState !== xhr.DONE) {
xhr.abort();
}
};
});
}));
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpXhrBackend, deps: [{ token: i1.XhrFactory }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpXhrBackend }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpXhrBackend, decorators: [{
type: Injectable
}], ctorParameters: function () { return [{ type: i1.XhrFactory }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xhr.js","sourceRoot":"","sources":["../../../../../../../packages/common/http/src/xhr.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 {XhrFactory} from '@angular/common';\nimport {Injectable, ɵRuntimeError as RuntimeError} from '@angular/core';\nimport {from, Observable, Observer, of} from 'rxjs';\nimport {switchMap} from 'rxjs/operators';\n\nimport {HttpBackend} from './backend';\nimport {RuntimeErrorCode} from './errors';\nimport {HttpHeaders} from './headers';\nimport {HttpRequest} from './request';\nimport {HttpDownloadProgressEvent, HttpErrorResponse, HttpEvent, HttpEventType, HttpHeaderResponse, HttpJsonParseError, HttpResponse, HttpStatusCode, HttpUploadProgressEvent} from './response';\n\n\nconst XSSI_PREFIX = /^\\)\\]\\}',?\\n/;\n\n/**\n * Determine an appropriate URL for the response, by checking either\n * XMLHttpRequest.responseURL or the X-Request-URL header.\n */\nfunction getResponseUrl(xhr: any): string|null {\n  if ('responseURL' in xhr && xhr.responseURL) {\n    return xhr.responseURL;\n  }\n  if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {\n    return xhr.getResponseHeader('X-Request-URL');\n  }\n  return null;\n}\n\n/**\n * Uses `XMLHttpRequest` to send requests to a backend server.\n * @see {@link HttpHandler}\n * @see {@link JsonpClientBackend}\n *\n * @publicApi\n */\n@Injectable()\nexport class HttpXhrBackend implements HttpBackend {\n  constructor(private xhrFactory: XhrFactory) {}\n\n  /**\n   * Processes a request and returns a stream of response events.\n   * @param req The request object.\n   * @returns An observable of the response events.\n   */\n  handle(req: HttpRequest<any>): Observable<HttpEvent<any>> {\n    // Quick check to give a better error message when a user attempts to use\n    // HttpClient.jsonp() without installing the HttpClientJsonpModule\n    if (req.method === 'JSONP') {\n      throw new RuntimeError(\n          RuntimeErrorCode.MISSING_JSONP_MODULE,\n          (typeof ngDevMode === 'undefined' || ngDevMode) &&\n              `Cannot make a JSONP request without JSONP support. To fix the problem, either add the \\`withJsonpSupport()\\` call (if \\`provideHttpClient()\\` is used) or import the \\`HttpClientJsonpModule\\` in the root NgModule.`);\n    }\n\n    // Check whether this factory has a special function to load an XHR implementation\n    // for various non-browser environments. We currently limit it to only `ServerXhr`\n    // class, which needs to load an XHR implementation.\n    const xhrFactory: XhrFactory&{ɵloadImpl?: () => Promise<void>} = this.xhrFactory;\n    const source: Observable<void|null> =\n        xhrFactory.ɵloadImpl ? from(xhrFactory.ɵloadImpl()) : of(null);\n\n    return source.pipe(\n        switchMap(() => {\n          // Everything happens on Observable subscription.\n          return new Observable((observer: Observer<HttpEvent<any>>) => {\n            // Start by setting up the XHR object with request method, URL, and withCredentials\n            // flag.\n            const xhr = xhrFactory.build();\n            xhr.open(req.method, req.urlWithParams);\n            if (req.withCredentials) {\n              xhr.withCredentials = true;\n            }\n\n            // Add all the requested headers.\n            req.headers.forEach((name, values) => xhr.setRequestHeader(name, values.join(',')));\n\n            // Add an Accept header if one isn't present already.\n            if (!req.headers.has('Accept')) {\n              xhr.setRequestHeader('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                xhr.setRequestHeader('Content-Type', detectedType);\n              }\n            }\n\n            // Set the responseType if one was requested.\n            if (req.responseType) {\n              const responseType = req.responseType.toLowerCase();\n\n              // JSON responses need to be processed as text. This is because if the server\n              // returns an XSSI-prefixed JSON response, the browser will fail to parse it,\n              // xhr.response will be null, and xhr.responseText cannot be accessed to\n              // retrieve the prefixed JSON data in order to strip the prefix. Thus, all JSON\n              // is parsed by first requesting text and then applying JSON.parse.\n              xhr.responseType = ((responseType !== 'json') ? responseType : 'text') as any;\n            }\n\n            // Serialize the request body if one is present. If not, this will be set to null.\n            const reqBody = req.serializeBody();\n\n            // If progress events are enabled, response headers will be delivered\n            // in two events - the HttpHeaderResponse event and the full HttpResponse\n            // event. However, since response headers don't change in between these\n            // two events, it doesn't make sense to parse them twice. So headerResponse\n            // caches the data extracted from the response whenever it's first parsed,\n            // to ensure parsing isn't duplicated.\n            let headerResponse: HttpHeaderResponse|null = null;\n\n            // partialFromXhr extracts the HttpHeaderResponse from the current XMLHttpRequest\n            // state, and memoizes it into headerResponse.\n            const partialFromXhr = (): HttpHeaderResponse => {\n              if (headerResponse !== null) {\n                return headerResponse;\n              }\n\n              const statusText = xhr.statusText || 'OK';\n\n              // Parse headers from XMLHttpRequest - this step is lazy.\n              const headers = new HttpHeaders(xhr.getAllResponseHeaders());\n\n              // Read the response URL from the XMLHttpResponse instance and fall back on the\n              // request URL.\n              const url = getResponseUrl(xhr) || req.url;\n\n              // Construct the HttpHeaderResponse and memoize it.\n              headerResponse =\n                  new HttpHeaderResponse({headers, status: xhr.status, statusText, url});\n              return headerResponse;\n            };\n\n            // Next, a few closures are defined for the various events which XMLHttpRequest can\n            // emit. This allows them to be unregistered as event listeners later.\n\n            // First up is the load event, which represents a response being fully available.\n            const onLoad = () => {\n              // Read response state from the memoized partial data.\n              let {headers, status, statusText, url} = partialFromXhr();\n\n              // The body will be read out if present.\n              let body: any|null = null;\n\n              if (status !== HttpStatusCode.NoContent) {\n                // Use XMLHttpRequest.response if set, responseText otherwise.\n                body = (typeof xhr.response === 'undefined') ? xhr.responseText : xhr.response;\n              }\n\n              // Normalize another potential bug (this one comes from CORS).\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              let ok = status >= 200 && status < 300;\n\n              // Check whether the body needs to be parsed as JSON (in many cases the browser\n              // will have done that already).\n              if (req.responseType === 'json' && typeof body === 'string') {\n                // Save the original body, before attempting XSSI prefix stripping.\n                const originalBody = body;\n                body = body.replace(XSSI_PREFIX, '');\n                try {\n                  // Attempt the parse. If it fails, a parse error should be delivered to the\n                  // user.\n                  body = body !== '' ? JSON.parse(body) : null;\n                } catch (error) {\n                  // Since the JSON.parse failed, it's reasonable to assume this might not have\n                  // been a JSON response. Restore the original body (including any XSSI prefix)\n                  // to deliver a better error response.\n                  body = originalBody;\n\n                  // If this was an error request to begin with, leave it as a string, it\n                  // probably just isn't JSON. Otherwise, deliver the parsing error to the user.\n                  if (ok) {\n                    // Even though the response status was 2xx, this is still an error.\n                    ok = false;\n                    // The parse error contains the text of the body that failed to parse.\n                    body = {error, text: body} as HttpJsonParseError;\n                  }\n                }\n              }\n\n              if (ok) {\n                // A successful response is delivered on the event stream.\n                observer.next(new HttpResponse({\n                  body,\n                  headers,\n                  status,\n                  statusText,\n                  url: url || undefined,\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                // An unsuccessful request is delivered on the error channel.\n                observer.error(new HttpErrorResponse({\n                  // The error in this case is the response body (error from the server).\n                  error: body,\n                  headers,\n                  status,\n                  statusText,\n                  url: url || undefined,\n                }));\n              }\n            };\n\n            // The onError callback is called when something goes wrong at the network level.\n            // Connection timeout, DNS error, offline, etc. These are actual errors, and are\n            // transmitted on the error channel.\n            const onError = (error: ProgressEvent) => {\n              const {url} = partialFromXhr();\n              const res = new HttpErrorResponse({\n                error,\n                status: xhr.status || 0,\n                statusText: xhr.statusText || 'Unknown Error',\n                url: url || undefined,\n              });\n              observer.error(res);\n            };\n\n            // The sentHeaders flag tracks whether the HttpResponseHeaders event\n            // has been sent on the stream. This is necessary to track if progress\n            // is enabled since the event will be sent on only the first download\n            // progress event.\n            let sentHeaders = false;\n\n            // The download progress event handler, which is only registered if\n            // progress events are enabled.\n            const onDownProgress = (event: ProgressEvent) => {\n              // Send the HttpResponseHeaders event if it hasn't been sent already.\n              if (!sentHeaders) {\n                observer.next(partialFromXhr());\n                sentHeaders = true;\n              }\n\n              // Start building the download progress event to deliver on the response\n              // event stream.\n              let progressEvent: HttpDownloadProgressEvent = {\n                type: HttpEventType.DownloadProgress,\n                loaded: event.loaded,\n              };\n\n              // Set the total number of bytes in the event if it's available.\n              if (event.lengthComputable) {\n                progressEvent.total = event.total;\n              }\n\n              // If the request was for text content and a partial response is\n              // available on XMLHttpRequest, include it in the progress event\n              // to allow for streaming reads.\n              if (req.responseType === 'text' && !!xhr.responseText) {\n                progressEvent.partialText = xhr.responseText;\n              }\n\n              // Finally, fire the event.\n              observer.next(progressEvent);\n            };\n\n            // The upload progress event handler, which is only registered if\n            // progress events are enabled.\n            const onUpProgress = (event: ProgressEvent) => {\n              // Upload progress events are simpler. Begin building the progress\n              // event.\n              let progress: HttpUploadProgressEvent = {\n                type: HttpEventType.UploadProgress,\n                loaded: event.loaded,\n              };\n\n              // If the total number of bytes being uploaded is available, include\n              // it.\n              if (event.lengthComputable) {\n                progress.total = event.total;\n              }\n\n              // Send the event.\n              observer.next(progress);\n            };\n\n            // By default, register for load and error events.\n            xhr.addEventListener('load', onLoad);\n            xhr.addEventListener('error', onError);\n            xhr.addEventListener('timeout', onError);\n            xhr.addEventListener('abort', onError);\n\n            // Progress events are only enabled if requested.\n            if (req.reportProgress) {\n              // Download progress is always enabled if requested.\n              xhr.addEventListener('progress', onDownProgress);\n\n              // Upload progress depends on whether there is a body to upload.\n              if (reqBody !== null && xhr.upload) {\n                xhr.upload.addEventListener('progress', onUpProgress);\n              }\n            }\n\n            // Fire the request, and notify the event stream that it was fired.\n            xhr.send(reqBody!);\n            observer.next({type: HttpEventType.Sent});\n            // This is the return from the Observable function, which is the\n            // request cancellation handler.\n            return () => {\n              // On a cancellation, remove all registered event listeners.\n              xhr.removeEventListener('error', onError);\n              xhr.removeEventListener('abort', onError);\n              xhr.removeEventListener('load', onLoad);\n              xhr.removeEventListener('timeout', onError);\n\n              if (req.reportProgress) {\n                xhr.removeEventListener('progress', onDownProgress);\n                if (reqBody !== null && xhr.upload) {\n                  xhr.upload.removeEventListener('progress', onUpProgress);\n                }\n              }\n\n              // Finally, abort the in-flight request.\n              if (xhr.readyState !== xhr.DONE) {\n                xhr.abort();\n              }\n            };\n          });\n        }),\n    );\n  }\n}\n"]}