@angular/common
Version:
Angular - commonly needed directives and services
2,293 lines • 73.4 kB
JavaScript
/**
* @license Angular v22.1.4
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
import * as i0 from '@angular/core';
import { ɵRuntimeError as _RuntimeError, InjectionToken, inject, NgZone, DestroyRef, ɵformatRuntimeError as _formatRuntimeError, Service, EnvironmentInjector, runInInjectionContext, DOCUMENT, Injectable, PendingTasks, ɵConsole as _Console, untracked, CSP_NONCE, Inject, ɵTracingService as _TracingService, makeEnvironmentProviders, NgModule } from '@angular/core';
import { finalize, concatMap, filter, map, switchMap } from 'rxjs/operators';
import { parseCookieValue, XhrFactory } from './_xhr-chunk.mjs';
import { PlatformLocation } from './_platform_location-chunk.mjs';
import { Observable, of, from } from 'rxjs';
class HttpHeaders {
headers;
normalizedNames = new Map();
lazyInit;
lazyUpdate = null;
constructor(headers) {
if (!headers) {
this.headers = new Map();
} else if (typeof headers === 'string') {
this.lazyInit = () => {
this.headers = new Map();
headers.split('\n').forEach(line => {
const index = line.indexOf(':');
if (index > 0) {
const name = line.slice(0, index);
const value = line.slice(index + 1).trim();
this.addHeaderEntry(name, value);
}
});
};
} else if (typeof Headers !== 'undefined' && headers instanceof Headers) {
this.headers = new Map();
headers.forEach((value, name) => {
this.addHeaderEntry(name, value);
});
} else {
this.lazyInit = () => {
if (typeof ngDevMode === 'undefined' || ngDevMode) {
assertValidHeaders(headers);
}
this.headers = new Map();
Object.entries(headers).forEach(([name, values]) => {
this.setHeaderEntries(name, values);
});
};
}
}
has(name) {
this.init();
return this.headers.has(name.toLowerCase());
}
get(name) {
this.init();
const values = this.headers.get(name.toLowerCase());
return values && values.length > 0 ? values[0] : null;
}
keys() {
this.init();
return Array.from(this.normalizedNames.values());
}
getAll(name) {
this.init();
return this.headers.get(name.toLowerCase()) || null;
}
append(name, value) {
return this.clone({
name,
value,
op: 'a'
});
}
set(name, value) {
return this.clone({
name,
value,
op: 's'
});
}
delete(name, value) {
return this.clone({
name,
value,
op: 'd'
});
}
maybeSetNormalizedName(name, lcName) {
if (!this.normalizedNames.has(lcName)) {
this.normalizedNames.set(lcName, name);
}
}
init() {
if (!!this.lazyInit) {
if (this.lazyInit instanceof HttpHeaders) {
this.copyFrom(this.lazyInit);
} else {
this.lazyInit();
}
this.lazyInit = null;
if (!!this.lazyUpdate) {
this.lazyUpdate.forEach(update => this.applyUpdate(update));
this.lazyUpdate = null;
}
}
}
copyFrom(other) {
other.init();
for (const [key, values] of other.headers.entries()) {
this.headers.set(key, values);
this.normalizedNames.set(key, other.normalizedNames.get(key));
}
}
clone(update) {
const clone = new HttpHeaders();
clone.lazyInit = !!this.lazyInit && this.lazyInit instanceof HttpHeaders ? this.lazyInit : this;
clone.lazyUpdate = (this.lazyUpdate || []).concat([update]);
return clone;
}
applyUpdate(update) {
const key = update.name.toLowerCase();
switch (update.op) {
case 'a':
case 's':
let value = update.value;
if (typeof value === 'string') {
value = [value];
}
if (value.length === 0) {
return;
}
this.maybeSetNormalizedName(update.name, key);
const base = update.op === 'a' ? (this.headers.get(key) || []).slice() : [];
base.push(...value);
this.headers.set(key, base);
break;
case 'd':
const toDelete = update.value;
if (toDelete === undefined) {
this.headers.delete(key);
this.normalizedNames.delete(key);
} else {
const valuesToDelete = Array.isArray(toDelete) ? toDelete : [toDelete];
let existing = this.headers.get(key);
if (!existing) {
return;
}
existing = existing.filter(value => valuesToDelete.indexOf(value) === -1);
if (existing.length === 0) {
this.headers.delete(key);
this.normalizedNames.delete(key);
} else {
this.headers.set(key, existing);
}
}
break;
}
}
addHeaderEntry(name, value) {
const key = name.toLowerCase();
this.maybeSetNormalizedName(name, key);
if (this.headers.has(key)) {
this.headers.get(key).push(value);
} else {
this.headers.set(key, [value]);
}
}
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);
}
forEach(fn) {
this.init();
Array.from(this.normalizedNames.keys()).forEach(key => fn(this.normalizedNames.get(key), this.headers.get(key)));
}
}
function assertValidHeaders(headers) {
for (const [key, value] of Object.entries(headers)) {
if (!(typeof value === 'string' || typeof value === 'number') && !Array.isArray(value)) {
throw new Error(`Unexpected value of the \`${key}\` header provided. ` + `Expecting either a string, a number or an array, but got: \`${value}\`.`);
}
}
}
class HttpContextToken {
defaultValue;
constructor(defaultValue) {
this.defaultValue = defaultValue;
}
}
class HttpContext {
map = new Map();
set(token, value) {
this.map.set(token, value);
return this;
}
get(token) {
if (!this.map.has(token)) {
this.map.set(token, token.defaultValue());
}
return this.map.get(token);
}
delete(token) {
this.map.delete(token);
return this;
}
has(token) {
return this.map.has(token);
}
keys() {
return this.map.keys();
}
}
class HttpUrlEncodingCodec {
encodeKey(key) {
return standardEncoding(key);
}
encodeValue(value) {
return standardEncoding(value);
}
decodeKey(key) {
return decodeURIComponent(key);
}
decodeValue(value) {
return decodeURIComponent(value);
}
}
function paramParser(rawParams, codec) {
const map = new Map();
if (rawParams.length > 0) {
const params = rawParams.replace(/^\?/, '').split('&');
params.forEach(param => {
const eqIdx = param.indexOf('=');
const [key, val] = eqIdx == -1 ? [codec.decodeKey(param), ''] : [codec.decodeKey(param.slice(0, eqIdx)), codec.decodeValue(param.slice(eqIdx + 1))];
const list = map.get(key) || [];
list.push(val);
map.set(key, list);
});
}
return map;
}
const STANDARD_ENCODING_REGEX = /%(\d[a-f0-9])/gi;
const STANDARD_ENCODING_REPLACEMENTS = {
'40': '@',
'3A': ':',
'24': '$',
'2C': ',',
'3B': ';',
'3D': '=',
'3F': '?',
'2F': '/'
};
function standardEncoding(v) {
return encodeURIComponent(v).replace(STANDARD_ENCODING_REGEX, (s, t) => STANDARD_ENCODING_REPLACEMENTS[t] ?? s);
}
function valueToString(value) {
return `${value}`;
}
class HttpParams {
map;
encoder;
updates = null;
cloneFrom = null;
constructor(options = {}) {
this.encoder = options.encoder || new HttpUrlEncodingCodec();
if (options.fromString) {
if (options.fromObject) {
throw new _RuntimeError(2805, ngDevMode && 'Cannot specify both fromString and fromObject.');
}
this.map = paramParser(options.fromString, this.encoder);
} else if (!!options.fromObject) {
this.map = new Map();
Object.keys(options.fromObject).forEach(key => {
const value = options.fromObject[key];
const values = Array.isArray(value) ? value.map(valueToString) : [valueToString(value)];
this.map.set(key, values);
});
} else {
this.map = null;
}
}
has(param) {
this.init();
return this.map.has(param);
}
get(param) {
this.init();
const res = this.map.get(param);
return !!res ? res[0] : null;
}
getAll(param) {
this.init();
return this.map.get(param) || null;
}
keys() {
this.init();
return Array.from(this.map.keys());
}
append(param, value) {
return this.clone({
param,
value,
op: 'a'
});
}
appendAll(params) {
const updates = [];
Object.keys(params).forEach(param => {
const value = params[param];
if (Array.isArray(value)) {
value.forEach(_value => {
updates.push({
param,
value: _value,
op: 'a'
});
});
} else {
updates.push({
param,
value: value,
op: 'a'
});
}
});
return this.clone(updates);
}
set(param, value) {
return this.clone({
param,
value,
op: 's'
});
}
delete(param, value) {
return this.clone({
param,
value,
op: 'd'
});
}
toString() {
this.init();
return this.keys().map(key => {
const eKey = this.encoder.encodeKey(key);
return this.map.get(key).map(value => eKey + '=' + this.encoder.encodeValue(value)).join('&');
}).filter(param => param !== '').join('&');
}
clone(update) {
const clone = new HttpParams({
encoder: this.encoder
});
clone.cloneFrom = this.cloneFrom || this;
clone.updates = (this.updates || []).concat(update);
return clone;
}
init() {
if (this.map === null) {
this.map = new Map();
}
if (this.cloneFrom !== null) {
this.cloneFrom.init();
for (const [key, values] of this.cloneFrom.map.entries()) {
this.map.set(key, values);
}
this.updates.forEach(update => {
switch (update.op) {
case 'a':
case 's':
const base = update.op === 'a' ? (this.map.get(update.param) || []).slice() : [];
base.push(valueToString(update.value));
this.map.set(update.param, base);
break;
case 'd':
if (update.value !== undefined) {
const base = (this.map.get(update.param) || []).slice();
const idx = base.indexOf(valueToString(update.value));
if (idx !== -1) {
base.splice(idx, 1);
}
if (base.length > 0) {
this.map.set(update.param, base);
} else {
this.map.delete(update.param);
}
} else {
this.map.delete(update.param);
break;
}
}
});
this.cloneFrom = this.updates = null;
}
}
}
function mightHaveBody(method) {
switch (method) {
case 'DELETE':
case 'GET':
case 'HEAD':
case 'OPTIONS':
case 'JSONP':
return false;
default:
return true;
}
}
function isArrayBuffer(value) {
return typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer;
}
function isBlob(value) {
return typeof Blob !== 'undefined' && value instanceof Blob;
}
function isFormData(value) {
return typeof FormData !== 'undefined' && value instanceof FormData;
}
function isUrlSearchParams(value) {
return typeof URLSearchParams !== 'undefined' && value instanceof URLSearchParams;
}
const CONTENT_TYPE_HEADER = 'Content-Type';
const ACCEPT_HEADER = 'Accept';
const TEXT_CONTENT_TYPE = 'text/plain';
const JSON_CONTENT_TYPE = 'application/json';
const ACCEPT_HEADER_VALUE = `${JSON_CONTENT_TYPE}, ${TEXT_CONTENT_TYPE}, */*`;
class HttpRequest {
url;
body = null;
headers;
context;
reportProgress = false;
reportUploadProgress = false;
reportDownloadProgress = false;
withCredentials = false;
credentials;
keepalive = false;
cache;
priority;
mode;
redirect;
referrer;
integrity;
referrerPolicy;
responseType = 'json';
method;
params;
urlWithParams;
transferCache;
timeout;
constructor(method, url, third, fourth) {
this.url = url;
this.method = method.toUpperCase();
let options;
if (mightHaveBody(this.method) || !!fourth) {
this.body = third !== undefined ? third : null;
options = fourth;
} else {
options = third;
}
if (options) {
this.reportProgress = !!options.reportProgress;
this.reportUploadProgress = !!options.reportUploadProgress;
this.reportDownloadProgress = !!options.reportDownloadProgress;
this.withCredentials = !!options.withCredentials;
this.keepalive = !!options.keepalive;
if (!!options.responseType) {
this.responseType = options.responseType;
}
if (options.headers) {
this.headers = options.headers;
}
if (options.context) {
this.context = options.context;
}
if (options.params) {
this.params = options.params;
}
if (options.priority) {
this.priority = options.priority;
}
if (options.cache) {
this.cache = options.cache;
}
if (options.credentials) {
this.credentials = options.credentials;
}
if (typeof options.timeout === 'number') {
if (options.timeout < 1 || !Number.isInteger(options.timeout)) {
throw new _RuntimeError(2822, ngDevMode ? '`timeout` must be a positive integer value' : '');
}
this.timeout = options.timeout;
}
if (options.mode) {
this.mode = options.mode;
}
if (options.redirect) {
this.redirect = options.redirect;
}
if (options.integrity) {
this.integrity = options.integrity;
}
if (options.referrer !== undefined) {
this.referrer = options.referrer;
}
if (options.referrerPolicy) {
this.referrerPolicy = options.referrerPolicy;
}
this.transferCache = options.transferCache;
}
this.headers ??= new HttpHeaders();
this.context ??= new HttpContext();
if (!this.params) {
this.params = new HttpParams();
this.urlWithParams = url;
} else {
const params = this.params.toString();
if (params.length === 0) {
this.urlWithParams = url;
} else {
let urlWithoutFragment = url;
let fragment = '';
const hashIdx = url.indexOf('#');
if (hashIdx !== -1) {
fragment = url.substring(hashIdx);
urlWithoutFragment = url.substring(0, hashIdx);
}
const qIdx = urlWithoutFragment.indexOf('?');
const sep = qIdx === -1 ? '?' : qIdx < urlWithoutFragment.length - 1 ? '&' : '';
this.urlWithParams = urlWithoutFragment + sep + params + fragment;
}
}
}
serializeBody() {
if (this.body === null) {
return null;
}
if (typeof this.body === 'string' || isArrayBuffer(this.body) || isBlob(this.body) || isFormData(this.body) || isUrlSearchParams(this.body)) {
return this.body;
}
if (this.body instanceof HttpParams) {
return this.body.toString();
}
if (typeof this.body === 'object' || typeof this.body === 'boolean' || Array.isArray(this.body)) {
return JSON.stringify(this.body);
}
return this.body.toString();
}
detectContentTypeHeader() {
if (this.body === null) {
return null;
}
if (isFormData(this.body)) {
return null;
}
if (isBlob(this.body)) {
return this.body.type || null;
}
if (isArrayBuffer(this.body)) {
return null;
}
if (typeof this.body === 'string') {
return TEXT_CONTENT_TYPE;
}
if (this.body instanceof HttpParams) {
return 'application/x-www-form-urlencoded;charset=UTF-8';
}
if (typeof this.body === 'object' || typeof this.body === 'number' || typeof this.body === 'boolean') {
return JSON_CONTENT_TYPE;
}
return null;
}
clone(update = {}) {
const method = update.method || this.method;
const url = update.url || this.url;
const responseType = update.responseType || this.responseType;
const keepalive = update.keepalive ?? this.keepalive;
const priority = update.priority || this.priority;
const cache = update.cache || this.cache;
const mode = update.mode || this.mode;
const redirect = update.redirect || this.redirect;
const credentials = update.credentials || this.credentials;
const referrer = update.referrer ?? this.referrer;
const integrity = update.integrity || this.integrity;
const referrerPolicy = update.referrerPolicy || this.referrerPolicy;
const transferCache = update.transferCache ?? this.transferCache;
const timeout = update.timeout ?? this.timeout;
const body = update.body !== undefined ? update.body : this.body;
const withCredentials = update.withCredentials ?? this.withCredentials;
const reportProgress = update.reportProgress ?? this.reportProgress;
const reportUploadProgress = update.reportUploadProgress ?? this.reportUploadProgress;
const reportDownloadProgress = update.reportDownloadProgress ?? this.reportDownloadProgress;
let headers = update.headers || this.headers;
let params = update.params || this.params;
const context = update.context ?? this.context;
if (update.setHeaders !== undefined) {
headers = Object.keys(update.setHeaders).reduce((headers, name) => headers.set(name, update.setHeaders[name]), headers);
}
if (update.setParams) {
params = Object.keys(update.setParams).reduce((params, param) => params.set(param, update.setParams[param]), params);
}
return new HttpRequest(method, url, body, {
params,
headers,
context,
reportProgress,
reportUploadProgress,
reportDownloadProgress,
responseType,
withCredentials,
transferCache,
keepalive,
cache,
priority,
timeout,
mode,
redirect,
credentials,
referrer,
integrity,
referrerPolicy
});
}
}
var HttpEventType;
(function (HttpEventType) {
HttpEventType[HttpEventType["Sent"] = 0] = "Sent";
HttpEventType[HttpEventType["UploadProgress"] = 1] = "UploadProgress";
HttpEventType[HttpEventType["ResponseHeader"] = 2] = "ResponseHeader";
HttpEventType[HttpEventType["DownloadProgress"] = 3] = "DownloadProgress";
HttpEventType[HttpEventType["Response"] = 4] = "Response";
HttpEventType[HttpEventType["User"] = 5] = "User";
})(HttpEventType || (HttpEventType = {}));
class HttpResponseBase {
headers;
status;
statusText;
url;
ok;
type;
redirected;
responseType;
constructor(init, defaultStatus = 200, defaultStatusText = 'OK') {
this.headers = init.headers || new HttpHeaders();
this.status = init.status !== undefined ? init.status : defaultStatus;
this.statusText = init.statusText || defaultStatusText;
this.url = init.url || null;
this.redirected = init.redirected;
this.responseType = init.responseType;
this.ok = this.status >= 200 && this.status < 300;
}
}
class HttpHeaderResponse extends HttpResponseBase {
constructor(init = {}) {
super(init);
}
type = HttpEventType.ResponseHeader;
clone(update = {}) {
return new HttpHeaderResponse({
headers: update.headers || this.headers,
status: update.status !== undefined ? update.status : this.status,
statusText: update.statusText || this.statusText,
url: update.url || this.url || undefined
});
}
}
class HttpResponse extends HttpResponseBase {
body;
constructor(init = {}) {
super(init);
this.body = init.body !== undefined ? init.body : null;
}
type = HttpEventType.Response;
clone(update = {}) {
return new HttpResponse({
body: update.body !== undefined ? update.body : this.body,
headers: update.headers || this.headers,
status: update.status !== undefined ? update.status : this.status,
statusText: update.statusText || this.statusText,
url: update.url || this.url || undefined,
redirected: update.redirected ?? this.redirected,
responseType: update.responseType ?? this.responseType
});
}
}
class HttpErrorResponse extends HttpResponseBase {
name = 'HttpErrorResponse';
message;
error;
ok = false;
constructor(init) {
super(init, 0, 'Unknown Error');
if (this.status >= 200 && this.status < 300) {
this.message = `Http failure during parsing for ${init.url || '(unknown url)'}`;
} else {
this.message = `Http failure response for ${init.url || '(unknown url)'}: ${init.status} ${init.statusText}`;
}
this.error = init.error || null;
}
}
const HTTP_STATUS_CODE_OK = 200;
const HTTP_STATUS_CODE_NO_CONTENT = 204;
var HttpStatusCode;
(function (HttpStatusCode) {
HttpStatusCode[HttpStatusCode["Continue"] = 100] = "Continue";
HttpStatusCode[HttpStatusCode["SwitchingProtocols"] = 101] = "SwitchingProtocols";
HttpStatusCode[HttpStatusCode["Processing"] = 102] = "Processing";
HttpStatusCode[HttpStatusCode["EarlyHints"] = 103] = "EarlyHints";
HttpStatusCode[HttpStatusCode["Ok"] = 200] = "Ok";
HttpStatusCode[HttpStatusCode["Created"] = 201] = "Created";
HttpStatusCode[HttpStatusCode["Accepted"] = 202] = "Accepted";
HttpStatusCode[HttpStatusCode["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
HttpStatusCode[HttpStatusCode["NoContent"] = 204] = "NoContent";
HttpStatusCode[HttpStatusCode["ResetContent"] = 205] = "ResetContent";
HttpStatusCode[HttpStatusCode["PartialContent"] = 206] = "PartialContent";
HttpStatusCode[HttpStatusCode["MultiStatus"] = 207] = "MultiStatus";
HttpStatusCode[HttpStatusCode["AlreadyReported"] = 208] = "AlreadyReported";
HttpStatusCode[HttpStatusCode["ImUsed"] = 226] = "ImUsed";
HttpStatusCode[HttpStatusCode["MultipleChoices"] = 300] = "MultipleChoices";
HttpStatusCode[HttpStatusCode["MovedPermanently"] = 301] = "MovedPermanently";
HttpStatusCode[HttpStatusCode["Found"] = 302] = "Found";
HttpStatusCode[HttpStatusCode["SeeOther"] = 303] = "SeeOther";
HttpStatusCode[HttpStatusCode["NotModified"] = 304] = "NotModified";
HttpStatusCode[HttpStatusCode["UseProxy"] = 305] = "UseProxy";
HttpStatusCode[HttpStatusCode["Unused"] = 306] = "Unused";
HttpStatusCode[HttpStatusCode["TemporaryRedirect"] = 307] = "TemporaryRedirect";
HttpStatusCode[HttpStatusCode["PermanentRedirect"] = 308] = "PermanentRedirect";
HttpStatusCode[HttpStatusCode["BadRequest"] = 400] = "BadRequest";
HttpStatusCode[HttpStatusCode["Unauthorized"] = 401] = "Unauthorized";
HttpStatusCode[HttpStatusCode["PaymentRequired"] = 402] = "PaymentRequired";
HttpStatusCode[HttpStatusCode["Forbidden"] = 403] = "Forbidden";
HttpStatusCode[HttpStatusCode["NotFound"] = 404] = "NotFound";
HttpStatusCode[HttpStatusCode["MethodNotAllowed"] = 405] = "MethodNotAllowed";
HttpStatusCode[HttpStatusCode["NotAcceptable"] = 406] = "NotAcceptable";
HttpStatusCode[HttpStatusCode["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
HttpStatusCode[HttpStatusCode["RequestTimeout"] = 408] = "RequestTimeout";
HttpStatusCode[HttpStatusCode["Conflict"] = 409] = "Conflict";
HttpStatusCode[HttpStatusCode["Gone"] = 410] = "Gone";
HttpStatusCode[HttpStatusCode["LengthRequired"] = 411] = "LengthRequired";
HttpStatusCode[HttpStatusCode["PreconditionFailed"] = 412] = "PreconditionFailed";
HttpStatusCode[HttpStatusCode["PayloadTooLarge"] = 413] = "PayloadTooLarge";
HttpStatusCode[HttpStatusCode["UriTooLong"] = 414] = "UriTooLong";
HttpStatusCode[HttpStatusCode["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
HttpStatusCode[HttpStatusCode["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
HttpStatusCode[HttpStatusCode["ExpectationFailed"] = 417] = "ExpectationFailed";
HttpStatusCode[HttpStatusCode["ImATeapot"] = 418] = "ImATeapot";
HttpStatusCode[HttpStatusCode["MisdirectedRequest"] = 421] = "MisdirectedRequest";
HttpStatusCode[HttpStatusCode["UnprocessableEntity"] = 422] = "UnprocessableEntity";
HttpStatusCode[HttpStatusCode["Locked"] = 423] = "Locked";
HttpStatusCode[HttpStatusCode["FailedDependency"] = 424] = "FailedDependency";
HttpStatusCode[HttpStatusCode["TooEarly"] = 425] = "TooEarly";
HttpStatusCode[HttpStatusCode["UpgradeRequired"] = 426] = "UpgradeRequired";
HttpStatusCode[HttpStatusCode["PreconditionRequired"] = 428] = "PreconditionRequired";
HttpStatusCode[HttpStatusCode["TooManyRequests"] = 429] = "TooManyRequests";
HttpStatusCode[HttpStatusCode["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
HttpStatusCode[HttpStatusCode["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
HttpStatusCode[HttpStatusCode["InternalServerError"] = 500] = "InternalServerError";
HttpStatusCode[HttpStatusCode["NotImplemented"] = 501] = "NotImplemented";
HttpStatusCode[HttpStatusCode["BadGateway"] = 502] = "BadGateway";
HttpStatusCode[HttpStatusCode["ServiceUnavailable"] = 503] = "ServiceUnavailable";
HttpStatusCode[HttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
HttpStatusCode[HttpStatusCode["HttpVersionNotSupported"] = 505] = "HttpVersionNotSupported";
HttpStatusCode[HttpStatusCode["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
HttpStatusCode[HttpStatusCode["InsufficientStorage"] = 507] = "InsufficientStorage";
HttpStatusCode[HttpStatusCode["LoopDetected"] = 508] = "LoopDetected";
HttpStatusCode[HttpStatusCode["NotExtended"] = 510] = "NotExtended";
HttpStatusCode[HttpStatusCode["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
})(HttpStatusCode || (HttpStatusCode = {}));
const XSSI_PREFIX$1 = /^\)\]\}',?\n/;
const DEFAULT_SSR_MAX_RESPONSE_BODY_SIZE = 1024 * 1024;
const HTTP_FETCH_MAX_RESPONSE_SIZE = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'HTTP_FETCH_MAX_RESPONSE_SIZE' : '', {
factory: () => typeof ngServerMode !== 'undefined' && ngServerMode ? DEFAULT_SSR_MAX_RESPONSE_BODY_SIZE : null
});
class FetchBackend {
fetchImpl = inject(FetchFactory, {
optional: true
})?.fetch ?? ((...args) => globalThis.fetch(...args));
ngZone = inject(NgZone);
destroyRef = inject(DestroyRef);
maxResponseSize = inject(HTTP_FETCH_MAX_RESPONSE_SIZE);
handle(request) {
return new Observable(observer => {
const aborter = new AbortController();
let done = false;
const wrappedObserver = {
next: val => {
if (val.type === HttpEventType.Response) {
done = true;
}
observer.next(val);
},
error: err => {
done = true;
observer.error(err);
},
complete: () => {
done = true;
observer.complete();
}
};
this.doRequest(request, aborter.signal, wrappedObserver).then(noop, error => wrappedObserver.error(new HttpErrorResponse({
error
})));
let timeoutId;
if (request.timeout) {
timeoutId = this.ngZone.runOutsideAngular(() => setTimeout(() => {
if (!aborter.signal.aborted) {
aborter.abort(new DOMException('signal timed out', 'TimeoutError'));
}
}, request.timeout));
}
return () => {
if (timeoutId !== undefined) {
clearTimeout(timeoutId);
}
if (!done && !aborter.signal.aborted) {
aborter.abort();
}
};
});
}
async doRequest(request, signal, observer) {
const init = this.createRequestInit(request);
let response;
try {
const fetchPromise = this.ngZone.runOutsideAngular(() => this.fetchImpl(request.urlWithParams, {
signal,
...init
}));
silenceSuperfluousUnhandledPromiseRejection(fetchPromise);
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 = response.url || request.urlWithParams;
let status = response.status;
let body = null;
const reportDownloadProgress = request.reportProgress || request.reportDownloadProgress;
if (reportDownloadProgress) {
observer.next(new HttpHeaderResponse({
headers,
status,
statusText,
url
}));
}
if (response.body) {
const contentType = response.headers.get(CONTENT_TYPE_HEADER) ?? '';
const contentLength = response.headers.get('content-length');
const contentLengthValue = contentLength !== null ? Number(contentLength) : NaN;
if (this.maxResponseSize !== null && Number.isFinite(contentLengthValue) && contentLengthValue > this.maxResponseSize) {
await response.body.cancel();
throwBodyTooLargeError(this.maxResponseSize);
}
const chunks = [];
const reader = response.body.getReader();
let receivedLength = 0;
let decoder;
let partialText;
const reqZone = typeof Zone !== 'undefined' && Zone.current;
let canceled = false;
await this.ngZone.runOutsideAngular(async () => {
while (true) {
if (this.destroyRef.destroyed) {
await reader.cancel();
canceled = true;
break;
}
const {
done,
value
} = await reader.read();
if (done) {
break;
}
chunks.push(value);
receivedLength += value.length;
if (this.maxResponseSize !== null && receivedLength > this.maxResponseSize) {
await reader.cancel();
throwBodyTooLargeError(this.maxResponseSize);
}
if (reportDownloadProgress) {
partialText = request.responseType === 'text' ? (partialText ?? '') + (decoder ??= getTextDecoder(contentType)).decode(value, {
stream: true
}) : undefined;
const reportProgress = () => observer.next({
type: HttpEventType.DownloadProgress,
total: Number.isFinite(contentLengthValue) ? contentLengthValue : undefined,
loaded: receivedLength,
partialText
});
reqZone ? reqZone.run(reportProgress) : reportProgress();
}
}
});
if (canceled) {
observer.complete();
return;
}
const chunksAll = this.concatChunks(chunks, receivedLength);
try {
body = this.parseBody(request, chunksAll, contentType, status);
} catch (error) {
observer.error(new HttpErrorResponse({
error,
headers: new HttpHeaders(response.headers),
status: response.status,
statusText: response.statusText,
url: response.url || request.urlWithParams
}));
return;
}
}
if (status === 0) {
status = body ? HTTP_STATUS_CODE_OK : 0;
}
const ok = status >= 200 && status < 300;
const redirected = response.redirected;
const responseType = response.type;
if (ok) {
observer.next(new HttpResponse({
body,
headers,
status,
statusText,
url,
redirected,
responseType
}));
observer.complete();
} else {
observer.error(new HttpErrorResponse({
error: body,
headers,
status,
statusText,
url,
redirected,
responseType
}));
}
}
parseBody(request, binContent, contentType, status) {
switch (request.responseType) {
case 'json':
const text = new TextDecoder().decode(binContent).replace(XSSI_PREFIX$1, '');
if (text === '') {
return null;
}
try {
return JSON.parse(text);
} catch (e) {
if (status < 200 || status >= 300) {
return text;
}
throw e;
}
case 'text':
return getTextDecoder(contentType).decode(binContent);
case 'blob':
return new Blob([binContent], {
type: contentType
});
case 'arraybuffer':
return binContent.buffer;
}
}
createRequestInit(req) {
if (req.reportUploadProgress) {
throw new _RuntimeError(2824, ngDevMode && 'The FetchBackend does not support upload progress reporting. Please use `withXhr()` on your `provideHttpClient()` configuration if you want to report upload progress.');
}
const headers = {};
let credentials;
credentials = req.credentials;
if (req.withCredentials) {
(typeof ngDevMode === 'undefined' || ngDevMode) && warningOptionsMessage(req);
credentials = 'include';
}
req.headers.forEach((name, values) => headers[name] = values.join(','));
if (!req.headers.has(ACCEPT_HEADER)) {
headers[ACCEPT_HEADER] = ACCEPT_HEADER_VALUE;
}
if (!req.headers.has(CONTENT_TYPE_HEADER)) {
const detectedType = req.detectContentTypeHeader();
if (detectedType !== null) {
headers[CONTENT_TYPE_HEADER] = detectedType;
}
}
return {
body: req.serializeBody(),
method: req.method,
headers,
credentials,
keepalive: req.keepalive,
cache: req.cache,
priority: req.priority,
mode: req.mode,
redirect: req.redirect,
referrer: req.referrer,
integrity: req.integrity,
referrerPolicy: req.referrerPolicy
};
}
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 ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: FetchBackend,
deps: [],
target: i0.ɵɵFactoryTarget.Service
});
static ɵprov = i0.ɵɵngDeclareService({
minVersion: "22.0.0",
version: "22.1.4",
ngImport: i0,
type: FetchBackend
});
}
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: FetchBackend,
decorators: [{
type: Service
}]
});
class FetchFactory {}
function noop() {}
function warningOptionsMessage(req) {
if (req.credentials && req.withCredentials) {
console.warn(_formatRuntimeError(2819, `Angular detected that a \`HttpClient\` request has both \`withCredentials: true\` and \`credentials: '${req.credentials}'\` options. The \`withCredentials\` option is overriding the explicit \`credentials\` setting to 'include'. Consider removing \`withCredentials\` and using \`credentials: '${req.credentials}'\` directly for clarity.`));
}
}
function silenceSuperfluousUnhandledPromiseRejection(promise) {
promise.then(noop, noop);
}
function throwBodyTooLargeError(maxResponseSize) {
throw new _RuntimeError(-2825, ngDevMode && `Fetch response body exceeded the configured buffer limit (${maxResponseSize} bytes).`);
}
const CHARSET_REGEX = /charset=\s*["']?([^;"'\s]+)["']?/i;
function getTextDecoder(contentType) {
const match = contentType.match(CHARSET_REGEX);
if (match !== null) {
try {
return new TextDecoder(match[1]);
} catch {}
}
return new TextDecoder();
}
const XSRF_ENABLED = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'XSRF_ENABLED' : '', {
factory: () => true
});
const XSRF_DEFAULT_COOKIE_NAME = 'XSRF-TOKEN';
const XSRF_COOKIE_NAME = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'XSRF_COOKIE_NAME' : '', {
factory: () => XSRF_DEFAULT_COOKIE_NAME
});
const XSRF_DEFAULT_HEADER_NAME = 'X-XSRF-TOKEN';
const XSRF_HEADER_NAME = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'XSRF_HEADER_NAME' : '', {
factory: () => XSRF_DEFAULT_HEADER_NAME
});
class HttpXsrfCookieExtractor {
cookieName = inject(XSRF_COOKIE_NAME);
doc = inject(DOCUMENT);
lastCookieString = '';
lastToken = null;
parseCount = 0;
getToken() {
if (typeof ngServerMode !== 'undefined' && ngServerMode) {
return null;
}
const cookieString = this.doc.cookie || '';
if (cookieString !== this.lastCookieString) {
this.parseCount++;
this.lastToken = parseCookieValue(cookieString, this.cookieName);
this.lastCookieString = cookieString;
}
return this.lastToken;
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpXsrfCookieExtractor,
deps: [],
target: i0.ɵɵFactoryTarget.Service
});
static ɵprov = i0.ɵɵngDeclareService({
minVersion: "22.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpXsrfCookieExtractor
});
}
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpXsrfCookieExtractor,
decorators: [{
type: Service
}]
});
class HttpXsrfTokenExtractor {
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpXsrfTokenExtractor,
deps: [],
target: i0.ɵɵFactoryTarget.Injectable
});
static ɵprov = i0.ɵɵngDeclareInjectable({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpXsrfTokenExtractor,
providedIn: 'root',
useExisting: HttpXsrfCookieExtractor
});
}
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpXsrfTokenExtractor,
decorators: [{
type: Injectable,
args: [{
providedIn: 'root',
useExisting: HttpXsrfCookieExtractor
}]
}]
});
function xsrfInterceptorFn(req, next) {
if (!inject(XSRF_ENABLED) || req.method === 'GET' || req.method === 'HEAD') {
return next(req);
}
try {
const locationHref = inject(PlatformLocation).href;
const {
origin: locationOrigin
} = new URL(locationHref);
const {
origin: requestOrigin
} = new URL(req.url, locationOrigin);
if (locationOrigin !== requestOrigin) {
return next(req);
}
} catch {
return next(req);
}
const token = inject(HttpXsrfTokenExtractor).getToken();
const headerName = inject(XSRF_HEADER_NAME);
if (token != null && !req.headers.has(headerName)) {
req = req.clone({
headers: req.headers.set(headerName, token)
});
}
return next(req);
}
class HttpXsrfInterceptor {
injector = inject(EnvironmentInjector);
intercept(initialRequest, next) {
return runInInjectionContext(this.injector, () => xsrfInterceptorFn(initialRequest, downstreamRequest => next.handle(downstreamRequest)));
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpXsrfInterceptor,
deps: [],
target: i0.ɵɵFactoryTarget.Injectable
});
static ɵprov = i0.ɵɵngDeclareInjectable({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpXsrfInterceptor
});
}
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpXsrfInterceptor,
decorators: [{
type: Injectable
}]
});
function interceptorChainEndFn(req, finalHandlerFn) {
return finalHandlerFn(req);
}
function adaptLegacyInterceptorToChain(chainTailFn, interceptor) {
return (initialRequest, finalHandlerFn) => interceptor.intercept(initialRequest, {
handle: downstreamRequest => chainTailFn(downstreamRequest, finalHandlerFn)
});
}
function chainedInterceptorFn(chainTailFn, interceptorFn, injector) {
return (initialRequest, finalHandlerFn) => runInInjectionContext(injector, () => interceptorFn(initialRequest, downstreamRequest => chainTailFn(downstreamRequest, finalHandlerFn)));
}
const HTTP_INTERCEPTORS = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'HTTP_INTERCEPTORS' : '');
const HTTP_INTERCEPTOR_FNS = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'HTTP_INTERCEPTOR_FNS' : '', {
factory: () => [xsrfInterceptorFn]
});
const HTTP_ROOT_INTERCEPTOR_FNS = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'HTTP_ROOT_INTERCEPTOR_FNS' : '');
const REQUESTS_CONTRIBUTE_TO_STABILITY = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'REQUESTS_CONTRIBUTE_TO_STABILITY' : '', {
factory: () => true
});
function legacyInterceptorFnFactory() {
let chain = null;
return (req, handler) => {
if (chain === null) {
const interceptors = inject(HTTP_INTERCEPTORS, {
optional: true
}) ?? [];
chain = interceptors.reduceRight(adaptLegacyInterceptorToChain, interceptorChainEndFn);
}
const pendingTasks = inject(PendingTasks);
const contributeToStability = inject(REQUESTS_CONTRIBUTE_TO_STABILITY);
if (contributeToStability) {
const removeTask = pendingTasks.add();
return chain(req, handler).pipe(finalize(removeTask));
} else {
return chain(req, handler);
}
};
}
class HttpBackend {
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpBackend,
deps: [],
target: i0.ɵɵFactoryTarget.Injectable
});
static ɵprov = i0.ɵɵngDeclareInjectable({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpBackend,
providedIn: 'root',
useExisting: FetchBackend
});
}
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpBackend,
decorators: [{
type: Injectable,
args: [{
providedIn: 'root',
useExisting: FetchBackend
}]
}]
});
let fetchBackendWarningDisplayed = false;
class HttpInterceptorHandler {
backend;
injector;
chain = null;
pendingTasks = inject(PendingTasks);
contributeToStability = inject(REQUESTS_CONTRIBUTE_TO_STABILITY);
constructor(backend, injector) {
this.backend = backend;
this.injector = injector;
if ((typeof ngDevMode === 'undefined' || ngDevMode) && !fetchBackendWarningDisplayed) {
const isTestingBackend = this.backend.isTestingBackend;
if (typeof ngServerMode !== 'undefined' && ngServerMode && !(this.backend instanceof FetchBackend) && !isTestingBackend) {
fetchBackendWarningDisplayed = true;
injector.get(_Console).warn(_formatRuntimeError(2801, 'Angular detected that `HttpClient` is not configured ' + "to use `fetch` APIs. It's strongly recommended to " + 'enable `fetch` for applications that use Server-Side Rendering ' + 'for better performance and compatibility. ' + 'To enable `fetch`, remove the `withXhr()` feature from the `provideHttpClient()` call'));
}
}
}
handle(initialRequest) {
if (this.chain === null) {
const parentHandler = this.injector.get(HttpHandler, null, {
skipSelf: true
});
const isDelegating = parentHandler !== null && this.backend === parentHandler;
const rootInterceptorFns = this.injector.get(HTTP_ROOT_INTERCEPTOR_FNS, [], isDelegating ? {
self: true
} : undefined);
const dedupedInterceptorFns = Array.from(new Set([...this.injector.get(HTTP_INTERCEPTOR_FNS), ...rootInterceptorFns]));
this.chain = dedupedInterceptorFns.reduceRight((nextSequencedFn, interceptorFn) => chainedInterceptorFn(nextSequencedFn, interceptorFn, this.injector), interceptorChainEndFn);
}
const chain = this.chain;
if (this.contributeToStability) {
const removeTask = this.pendingTasks.add();
return untracked(() => chain(initialRequest, downstreamRequest => this.backend.handle(downstreamRequest))).pipe(finalize(removeTask));
} else {
return untracked(() => chain(initialRequest, downstreamRequest => this.backend.handle(downstreamRequest)));
}
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpInterceptorHandler,
deps: [{
token: HttpBackend
}, {
token: i0.EnvironmentInjector
}],
target: i0.ɵɵFactoryTarget.Injectable
});
static ɵprov = i0.ɵɵngDeclareInjectable({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpInterceptorHandler,
providedIn: 'root'
});
}
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpInterceptorHandler,
decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}],
ctorParameters: () => [{
type: HttpBackend
}, {
type: i0.EnvironmentInjector
}]
});
class HttpHandler {
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpHandler,
deps: [],
target: i0.ɵɵFactoryTarget.Injectable
});
static ɵprov = i0.ɵɵngDeclareInjectable({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpHandler,
providedIn: 'root',
useExisting: HttpInterceptorHandler
});
}
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpHandler,
decorators: [{
type: Injectable,
args: [{
providedIn: 'root',
useExisting: HttpInterceptorHandler
}]
}]
});
function addBody(options, body) {
return {
body,
...options
};
}
class HttpClient {
handler;
constructor(handler) {
this.handler = handler;
}
request(first, url, options = {}) {
let req;
if (first instanceof HttpRequest) {
req = first;
} else {
let headers = undefined;
if (options.headers instanceof HttpHeaders) {
headers = options.headers;
} else {
headers = new HttpHeaders(options.headers);
}
let params = undefined;
if (!!options.params) {
if (options.params instanceof HttpParams) {
params = options.params;
} else {
params = new HttpParams({
fromObject: options.params
});
}
}
req = new HttpRequest(first, url, options.body !== undefined ? options.body : null, {
headers,
context: options.context,
params,
reportProgress: options.reportProgress,
reportUploadProgress: options.reportUploadProgress,
reportDownloadProgress: options.reportDownloadProgress,
responseType: options.responseType || 'json',
withCredentials: options.withCredentials,
transferCache: options.transferCache,
keepalive: options.keepalive,
priority: options.priority,
cache: options.cache,
mode: options.mode,
redirect: options.redirect,
credentials: options.credentials,
referrer: options.referrer,
referrerPolicy: options.referrerPolicy,
integrity: options.integrity,
timeout: options.timeout
});
}
const events$ = of(req).pipe(concatMap(req => this.handler.handle(req)));
if (first instanceof HttpRequest || options.observe === 'events') {
return events$;
}
const res$ = events$.pipe(filter(event => event instanceof HttpResponse));
switch (options.observe || 'body') {
case 'body':
switch (req.responseType) {
case 'arraybuffer':
return res$.pipe(map(res => {
if (res.body !== null && !(res.body instanceof ArrayBuffer)) {
throw new _RuntimeError(2806, ngDevMode && 'Response is not an ArrayBuffer.');
}
return res.body;
}));
case 'blob':
return res$.pipe(map(res => {
if (res.body !== null && !(res.body instanceof Blob)) {
throw new _RuntimeError(2807, ngDevMode && 'Response is not a Blob.');
}
return res.body;
}));
case 'text':
return res$.pipe(map(res => {
if (res.body !== null && typeof res.body !== 'string') {
throw new _RuntimeError(2808, ngDevMode && 'Response is not a string.');
}
return res.body;
}));
case 'json':
default:
return res$.pipe(map(res => res.body));
}
case 'response':
return res$;
default:
throw new _RuntimeError(2809, ngDevMode && `Unreachable: unhandled observe type ${options.observe}}`);
}
}
delete(url, options = {}) {
return this.request('DELETE', url, options);
}
get(url, options = {}) {
return this.request('GET', url, options);
}
head(url, options = {}) {
return this.request('HEAD', url, options);
}
jsonp(url, callbackParam) {
return this.request('JSONP', url, {
params: new HttpParams().append(callbackParam, 'JSONP_CALLBACK'),
observe: 'body',
responseType: 'json'
});
}
options(url, options = {}) {
return this.request('OPTIONS', url, options);
}
patch(url, body, options = {}) {
return this.request('PATCH', url, addBody(options, body));
}
post(url, body, options = {}) {
return this.request('POST', url, addBody(options, body));
}
put(url, body, options = {}) {
return this.request('PUT', url, addBody(options, body));
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpClient,
deps: [{
token: HttpHandler
}],
target: i0.ɵɵFactoryTarget.Injectable
});
static ɵprov = i0.ɵɵngDeclareInjectable({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpClient,
providedIn: 'root'
});
}
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpClient,
decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}],
ctorParameters: () => [{
type: HttpHandler
}]
});
let nextRequestId = 0;
let foreignDocument;
const JSONP_ERR_NO_CALLBACK = 'JSONP injected script did not invoke callback.';
const JSONP_ERR_WRONG_METHOD = 'JSONP requests must use JSONP request method.';
const JSONP_ERR_WRONG_RESPONSE_TYPE = 'JSONP requests must use Json response type.';
const JSONP_ERR_HEADERS_NOT_SUPPORTED = 'JSONP requests do not support headers.';
const JSONP_ERR_UNSAFE_URL = 'JSONP requests only support absolute URLs with HTTP(S) protocols.';
class JsonpCallbackContext {}
function jsonpCallbackContext() {
if (typeof window === 'object') {
return window;
}
return {};
}
class JsonpClientBackend {
callbackMap;
document;
resolvedPromise = Promise.resolve();
nonce = inject(CSP_NONCE, {
optional: true
});
constructor(callbackMap, document) {
this.callbackMap = callbackMap;
this.document = document;
if (typeof ngDevMode === 'undefined' || ngDevMode) {
console.warn('JSONP support is deprecated as it can cause XSS vulnerabilities, and will be removed ' + 'in a future version of Angular. Please use standard HTTP requests instead.');
}
}
nextCallback() {
return `ng_jsonp_callback_${nextRequestId++}`;
}
handle(req) {
if (req.method !== 'JSONP') {
throw new _RuntimeError(2810, ngDevMode && JSONP_ERR_WRONG_METHOD);
} else if (req.responseType !== 'json') {
throw new _RuntimeError(2811, ngDevMode && JSONP_ERR_WRONG_RESPONSE_TYPE);
}
if (req.headers.keys().length > 0) {
throw new _RuntimeError(2812, ngDevMode && JSONP_ERR_HEADERS_NOT_SUPPORTED);
}
if (!this.isAllowedJsonpUrl(req.urlWithParams)) {
throw new _RuntimeError(2826, ngDevMode && JSONP_ERR_UNSAFE_URL);
}
return new Observable(observer => {
const callback = this.nextCallback();
const url = req.urlWithParams.replace(/=JSONP_CALLBACK(&|$)/, `=${callback}$1`);
const node = this.document.createElement('script');
node.src = url;
if (this.nonce) {
node.setAttribute('nonce', this.nonce);
}
let body = null;
let finished = false;
this.callbackMap[callback] = data => {
delete this.callbackMap[callback];
body = data;
finished = true;
};
const cleanup = () => {
node.removeEventListener('load', onLoad);
node.removeEventListener('error', onError);
node.remove();
delete this.callbackMap[callback];
};
const onLoad = () => {
this.resolvedPromise.then(() => {
cleanup();
if (!finished) {
observer.error(new HttpErrorResponse({
url,
status: 0,
statusText: 'JSONP Error',
error: new Error(JSONP_ERR_NO_CALLBACK)
}));
return;
}
observer.next(new HttpResponse({
body,
status: HTTP_STATUS_CODE_OK,
statusText: 'OK',
url
}));
observer.complete();
});
};
const onError = error => {
cleanup();
observer.error(new HttpErrorResponse({
error,
status: 0,
statusText: 'JSONP Error',
url
}));
};
node.addEventListener('load', onLoad);
node.addEventListener('error', onError);
this.document.body.appendChild(node);
observer.next({
type: HttpEventType.Sent
});
return () => {
if (!finished) {
this.removeListeners(node);
}
cleanup();
};
});
}
removeListeners(script) {
foreignDocument ??= this.document.implementation.createHTMLDocument();
foreignDocument.adoptNode(script);
}
isAllowedJsonpUrl(url) {
return /^https?:\/\//i.test(url);
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: JsonpClientBackend,
deps: [{
token: JsonpCallbackContext
}, {
token: DOCUMENT
}],
target: i0.ɵɵFactoryTarget.Injectable
});
static ɵprov = i0.ɵɵngDeclareInjectable({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: JsonpClientBackend
});
}
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: JsonpClientBackend,
decorators: [{
type: Injectable
}],
ctorParameters: () => [{
type: JsonpCallbackContext
}, {
type: undefined,
decorators: [{
type: Inject,
args: [DOCUMENT]
}]
}]
});
function jsonpInterceptorFn(req, next) {
if (req.method === 'JSONP') {
return inject(JsonpClientBackend).handle(req);
}
return next(req);
}
class JsonpInterceptor {
injector;
constructor(injector) {
this.injector = injector;
}
intercept(initialRequest, next) {
return runInInjectionContext(this.injector, () => jsonpInterceptorFn(initialRequest, downstreamRequest => next.handle(downstreamRequest)));
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: JsonpInterceptor,
deps: [{
token: i0.EnvironmentInjector
}],
target: i0.ɵɵFactoryTarget.Injectable
});
static ɵprov = i0.ɵɵngDeclareInjectable({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: JsonpInterceptor
});
}
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: JsonpInterceptor,
decorators: [{
type: Injectable
}],
ctorParameters: () => [{
type: i0.EnvironmentInjector
}]
});
const XSSI_PREFIX = /^\)\]\}',?\n/;
function validateXhrCompatibility(req) {
const unsupportedOptions = [{
property: 'keepalive',
errorCode: 2813
}, {
property: 'cache',
errorCode: 2814
}, {
property: 'priority',
errorCode: 2815
}, {
property: 'mode',
errorCode: 2816
}, {
property: 'redirect',
errorCode: 2817
}, {
property: 'credentials',
errorCode: 2818
}, {
property: 'integrity',
errorCode: 2820
}, {
property: 'referrer',
errorCode: 2821
}, {
property: 'referrerPolicy',
errorCode: 2823
}];
for (const {
property,
errorCode
} of unsupportedOptions) {
if (req[property]) {
console.warn(_formatRuntimeError(errorCode, `Angular detected that a \`HttpClient\` request with the \`${property}\` option was sent using XHR, which does not support it. To use the \`${property}\` option, use the Fetch API by removing \`withXhr()\` from the \`provideHttpClient()\` call.`));
}
}
}
class HttpXhrBackend {
xhrFactory;
tracingService = inject(_TracingService, {
optional: true
});
constructor(xhrFactory) {
this.xhrFactory = xhrFactory;
}
maybePropagateTrace(fn) {
return this.tracingService?.propagate ? this.tracingService.propagate(fn) : fn;
}
handle(req) {
if (req.method === 'JSONP') {
throw new _RuntimeError(-2800, (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.`);
}
ngDevMode && validateXhrCompatibility(req);
const xhrFactory = this.xhrFactory;
const source = typeof ngServerMode !== 'undefined' && ngServerMode && xhrFactory.ɵloadImpl ? from(xhrFactory.ɵloadImpl()) : of(null);
return source.pipe(switchMap(() => {
return new Observable(observer => {
const xhr = xhrFactory.build();
xhr.open(req.method, req.urlWithParams);
if (req.withCredentials) {
xhr.withCredentials = true;
}
req.headers.forEach((name, values) => xhr.setRequestHeader(name, values.join(',')));
if (!req.headers.has(ACCEPT_HEADER)) {
xhr.setRequestHeader(ACCEPT_HEADER, ACCEPT_HEADER_VALUE);
}
if (!req.headers.has(CONTENT_TYPE_HEADER)) {
const detectedType = req.detectContentTypeHeader();
if (detectedType !== null) {
xhr.setRequestHeader(CONTENT_TYPE_HEADER, detectedType);
}
}
if (req.timeout) {
xhr.timeout = req.timeout;
}
if (req.responseType) {
const responseType = req.responseType.toLowerCase();
xhr.responseType = responseType !== 'json' ? responseType : 'text';
}
const reqBody = req.serializeBody();
let headerResponse = null;
const partialFromXhr = () => {
if (headerResponse !== null) {
return headerResponse;
}
const statusText = xhr.statusText || 'OK';
const headers = new HttpHeaders(xhr.getAllResponseHeaders());
const url = xhr.responseURL || req.url;
headerResponse = new HttpHeaderResponse({
headers,
status: xhr.status,
statusText,
url
});
return headerResponse;
};
const onLoad = this.maybePropagateTrace(() => {
let {
headers,
status,
statusText,
url
} = partialFromXhr();
let body = null;
if (status !== HTTP_STATUS_CODE_NO_CONTENT) {
body = typeof xhr.response === 'undefined' ? xhr.responseText : xhr.response;
}
if (status === 0) {
status = !!body ? HTTP_STATUS_CODE_OK : 0;
}
let ok = status >= 200 && status < 300;
if (req.responseType === 'json' && typeof body === 'string') {
const originalBody = body;
body = body.replace(XSSI_PREFIX, '');
try {
body = body !== '' ? JSON.parse(body) : null;
} catch (error) {
body = originalBody;
if (ok) {
ok = false;
body = {
error,
text: body
};
}
}
}
if (ok) {
observer.next(new HttpResponse({
body,
headers,
status,
statusText,
url: url || undefined
}));
observer.complete();
} else {
observer.error(new HttpErrorResponse({
error: body,
headers,
status,
statusText,
url: url || undefined
}));
}
});
const onError = this.maybePropagateTrace(error => {
const {
url
} = partialFromXhr();
const res = new HttpErrorResponse({
error,
status: xhr.status || 0,
statusText: xhr.statusText || 'Unknown Error',
url: url || undefined
});
observer.error(res);
});
let onTimeout = onError;
if (req.timeout) {
onTimeout = this.maybePropagateTrace(_ => {
const {
url
} = partialFromXhr();
const res = new HttpErrorResponse({
error: new DOMException('Request timed out', 'TimeoutError'),
status: xhr.status || 0,
statusText: xhr.statusText || 'Request timeout',
url: url || undefined
});
observer.error(res);
});
}
let sentHeaders = false;
const onDownProgress = this.maybePropagateTrace(event => {
if (!sentHeaders) {
observer.next(partialFromXhr());
sentHeaders = true;
}
let progressEvent = {
type: HttpEventType.DownloadProgress,
loaded: event.loaded
};
if (event.lengthComputable) {
progressEvent.total = event.total;
}
if (req.responseType === 'text' && !!xhr.responseText) {
progressEvent.partialText = xhr.responseText;
}
observer.next(progressEvent);
});
const onUpProgress = this.maybePropagateTrace(event => {
let progress = {
type: HttpEventType.UploadProgress,
loaded: event.loaded
};
if (event.lengthComputable) {
progress.total = event.total;
}
observer.next(progress);
});
xhr.addEventListener('load', onLoad);
xhr.addEventListener('error', onError);
xhr.addEventListener('timeout', onTimeout);
xhr.addEventListener('abort', onError);
const reportUploadProgress = req.reportProgress || req.reportUploadProgress;
const reportDownloadProgress = req.reportProgress || req.reportDownloadProgress;
if (reportDownloadProgress) {
xhr.addEventListener('progress', onDownProgress);
}
if (reportUploadProgress && reqBody !== null && xhr.upload) {
xhr.upload.addEventListener('progress', onUpProgress);
}
xhr.send(reqBody);
observer.next({
type: HttpEventType.Sent
});
return () => {
xhr.removeEventListener('error', onError);
xhr.removeEventListener('abort', onError);
xhr.removeEventListener('load', onLoad);
xhr.removeEventListener('timeout', onTimeout);
if (reportDownloadProgress) {
xhr.removeEventListener('progress', onDownProgress);
}
if (reportUploadProgress && reqBody !== null && xhr.upload) {
xhr.upload.removeEventListener('progress', onUpProgress);
}
if (xhr.readyState !== xhr.DONE) {
xhr.abort();
}
};
});
}));
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpXhrBackend,
deps: [{
token: XhrFactory
}],
target: i0.ɵɵFactoryTarget.Injectable
});
static ɵprov = i0.ɵɵngDeclareInjectable({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpXhrBackend,
providedIn: 'root'
});
}
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpXhrBackend,
decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}],
ctorParameters: () => [{
type: XhrFactory
}]
});
var HttpFeatureKind;
(function (HttpFeatureKind) {
HttpFeatureKind[HttpFeatureKind["Interceptors"] = 0] = "Interceptors";
HttpFeatureKind[HttpFeatureKind["LegacyInterceptors"] = 1] = "LegacyInterceptors";
HttpFeatureKind[HttpFeatureKind["CustomXsrfConfiguration"] = 2] = "CustomXsrfConfiguration";
HttpFeatureKind[HttpFeatureKind["NoXsrfProtection"] = 3] = "NoXsrfProtection";
HttpFeatureKind[HttpFeatureKind["JsonpSupport"] = 4] = "JsonpSupport";
HttpFeatureKind[HttpFeatureKind["RequestsMadeViaParent"] = 5] = "RequestsMadeViaParent";
HttpFeatureKind[HttpFeatureKind["Fetch"] = 6] = "Fetch";
HttpFeatureKind[HttpFeatureKind["Xhr"] = 7] = "Xhr";
})(HttpFeatureKind || (HttpFeatureKind = {}));
function makeHttpFeature(kind, providers) {
return {
ɵkind: kind,
ɵproviders: providers
};
}
function provideHttpClient(...features) {
if (ngDevMode) {
const featureKinds = new Set(features.map(f => f.ɵkind));
if (featureKinds.has(HttpFeatureKind.NoXsrfProtection) && featureKinds.has(HttpFeatureKind.CustomXsrfConfiguration)) {
throw new Error(`Configuration error: found both withXsrfConfiguration() and withNoXsrfProtection() in the same call to provideHttpClient(), which is a contradiction.`);
}
const hasBackendOverride = featureKinds.has(HttpFeatureKind.Fetch) || featureKinds.has(HttpFeatureKind.Xhr);
if (featureKinds.has(HttpFeatureKind.RequestsMadeViaParent) && hasBackendOverride) {
throw new Error(`Configuration error: withRequestsMadeViaParent() cannot be combined with withFetch() or withXhr() in the same call to provideHttpClient().`);
}
}
const providers = [HttpClient, FetchBackend, HttpInterceptorHandler, {
provide: HttpHandler,
useExisting: HttpInterceptorHandler
}, {
provide: HttpBackend,
useFactory: () => {
return inject(FetchBackend);
}
}, {
provide: HTTP_INTERCEPTOR_FNS,
useValue: xsrfInterceptorFn,
multi: true
}];
for (const feature of features) {
providers.push(...feature.ɵproviders);
}
return makeEnvironmentProviders(providers);
}
function withInterceptors(interceptorFns) {
return makeHttpFeature(HttpFeatureKind.Interceptors, interceptorFns.map(interceptorFn => {
return {
provide: HTTP_INTERCEPTOR_FNS,
useValue: interceptorFn,
multi: true
};
}));
}
const LEGACY_INTERCEPTOR_FN = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'LEGACY_INTERCEPTOR_FN' : '');
function withInterceptorsFromDi() {
return makeHttpFeature(HttpFeatureKind.LegacyInterceptors, [{
provide: LEGACY_INTERCEPTOR_FN,
useFactory: legacyInterceptorFnFactory
}, {
provide: HTTP_INTERCEPTOR_FNS,
useExisting: LEGACY_INTERCEPTOR_FN,
multi: true
}]);
}
function withXsrfConfiguration({
cookieName,
headerName
}) {
const providers = [];
if (cookieName !== undefined) {
providers.push({
provide: XSRF_COOKIE_NAME,
useValue: cookieName
});
}
if (headerName !== undefined) {
providers.push({
provide: XSRF_HEADER_NAME,
useValue: headerName
});
}
return makeHttpFeature(HttpFeatureKind.CustomXsrfConfiguration, providers);
}
function withNoXsrfProtection() {
return makeHttpFeature(HttpFeatureKind.NoXsrfProtection, [{
provide: XSRF_ENABLED,
useValue: false
}]);
}
function withJsonpSupport() {
return makeHttpFeature(HttpFeatureKind.JsonpSupport, [JsonpClientBackend, {
provide: JsonpCallbackContext,
useFactory: jsonpCallbackContext
}, {
provide: HTTP_INTERCEPTOR_FNS,
useValue: jsonpInterceptorFn,
multi: true
}]);
}
function withRequestsMadeViaParent() {
return makeHttpFeature(HttpFeatureKind.RequestsMadeViaParent, [{
provide: HttpBackend,
useFactory: () => {
const handlerFromParent = inject(HttpHandler, {
skipSelf: true,
optional: true
});
if (ngDevMode && handlerFromParent === null) {
throw new Error('withRequestsMadeViaParent() can only be used when the parent injector also configures HttpClient');
}
return handlerFromParent;
}
}]);
}
function withFetch() {
return makeHttpFeature(HttpFeatureKind.Fetch, [FetchBackend, {
provide: HttpBackend,
useExisting: FetchBackend
}]);
}
function withXhr() {
return makeHttpFeature(HttpFeatureKind.Xhr, [HttpXhrBackend, {
provide: HttpBackend,
useExisting: HttpXhrBackend
}]);
}
class HttpClientXsrfModule {
static disable() {
return {
ngModule: HttpClientXsrfModule,
providers: [withNoXsrfProtection().ɵproviders]
};
}
static withOptions(options = {}) {
return {
ngModule: HttpClientXsrfModule,
providers: withXsrfConfiguration(options).ɵproviders
};
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpClientXsrfModule,
deps: [],
target: i0.ɵɵFactoryTarget.NgModule
});
static ɵmod = i0.ɵɵngDeclareNgModule({
minVersion: "14.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpClientXsrfModule
});
static ɵinj = i0.ɵɵngDeclareInjector({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpClientXsrfModule,
providers: [HttpXsrfInterceptor, {
provide: HTTP_INTERCEPTORS,
useExisting: HttpXsrfInterceptor,
multi: true
}, {
provide: HttpXsrfTokenExtractor,
useClass: HttpXsrfCookieExtractor
}, withXsrfConfiguration({
cookieName: XSRF_DEFAULT_COOKIE_NAME,
headerName: XSRF_DEFAULT_HEADER_NAME
}).ɵproviders, {
provide: XSRF_ENABLED,
useValue: true
}]
});
}
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpClientXsrfModule,
decorators: [{
type: NgModule,
args: [{
providers: [HttpXsrfInterceptor, {
provide: HTTP_INTERCEPTORS,
useExisting: HttpXsrfInterceptor,
multi: true
}, {
provide: HttpXsrfTokenExtractor,
useClass: HttpXsrfCookieExtractor
}, withXsrfConfiguration({
cookieName: XSRF_DEFAULT_COOKIE_NAME,
headerName: XSRF_DEFAULT_HEADER_NAME
}).ɵproviders, {
provide: XSRF_ENABLED,
useValue: true
}]
}]
}]
});
class HttpClientModule {
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpClientModule,
deps: [],
target: i0.ɵɵFactoryTarget.NgModule
});
static ɵmod = i0.ɵɵngDeclareNgModule({
minVersion: "14.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpClientModule
});
static ɵinj = i0.ɵɵngDeclareInjector({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpClientModule,
providers: [provideHttpClient(withInterceptorsFromDi(), withXhr())]
});
}
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpClientModule,
decorators: [{
type: NgModule,
args: [{
providers: [provideHttpClient(withInterceptorsFromDi(), withXhr())]
}]
}]
});
class HttpClientJsonpModule {
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpClientJsonpModule,
deps: [],
target: i0.ɵɵFactoryTarget.NgModule
});
static ɵmod = i0.ɵɵngDeclareNgModule({
minVersion: "14.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpClientJsonpModule
});
static ɵinj = i0.ɵɵngDeclareInjector({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpClientJsonpModule,
providers: [withJsonpSupport().ɵproviders]
});
}
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.1.4",
ngImport: i0,
type: HttpClientJsonpModule,
decorators: [{
type: NgModule,
args: [{
providers: [withJsonpSupport().ɵproviders]
}]
}]
});
export { FetchBackend, HTTP_FETCH_MAX_RESPONSE_SIZE, HTTP_INTERCEPTORS, HTTP_ROOT_INTERCEPTOR_FNS, HttpBackend, HttpClient, HttpClientJsonpModule, HttpClientModule, HttpClientXsrfModule, HttpContext, HttpContextToken, HttpErrorResponse, HttpEventType, HttpFeatureKind, HttpHandler, HttpHeaderResponse, HttpHeaders, HttpInterceptorHandler, HttpParams, HttpRequest, HttpResponse, HttpResponseBase, HttpStatusCode, HttpUrlEncodingCodec, HttpXhrBackend, HttpXsrfTokenExtractor, JsonpClientBackend, JsonpInterceptor, REQUESTS_CONTRIBUTE_TO_STABILITY, provideHttpClient, withFetch, withInterceptors, withInterceptorsFromDi, withJsonpSupport, withNoXsrfProtection, withRequestsMadeViaParent, withXhr, withXsrfConfiguration };
//# sourceMappingURL=_module-chunk.mjs.map