@angular/common
Version:
Angular - commonly needed directives and services
286 lines • 43.7 kB
JavaScript
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { HttpContext } from './context';
import { HttpHeaders } from './headers';
import { HttpParams } from './params';
/**
* Determine whether the given HTTP method may include a body.
*/
function mightHaveBody(method) {
switch (method) {
case 'DELETE':
case 'GET':
case 'HEAD':
case 'OPTIONS':
case 'JSONP':
return false;
default:
return true;
}
}
/**
* Safely assert whether the given value is an ArrayBuffer.
*
* In some execution environments ArrayBuffer is not defined.
*/
function isArrayBuffer(value) {
return typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer;
}
/**
* Safely assert whether the given value is a Blob.
*
* In some execution environments Blob is not defined.
*/
function isBlob(value) {
return typeof Blob !== 'undefined' && value instanceof Blob;
}
/**
* Safely assert whether the given value is a FormData instance.
*
* In some execution environments FormData is not defined.
*/
function isFormData(value) {
return typeof FormData !== 'undefined' && value instanceof FormData;
}
/**
* Safely assert whether the given value is a URLSearchParams instance.
*
* In some execution environments URLSearchParams is not defined.
*/
function isUrlSearchParams(value) {
return typeof URLSearchParams !== 'undefined' && value instanceof URLSearchParams;
}
/**
* An outgoing HTTP request with an optional typed body.
*
* `HttpRequest` represents an outgoing request, including URL, method,
* headers, body, and other request configuration options. Instances should be
* assumed to be immutable. To modify a `HttpRequest`, the `clone`
* method should be used.
*
* @publicApi
*/
export class HttpRequest {
constructor(method, url, third, fourth) {
this.url = url;
/**
* The request body, or `null` if one isn't set.
*
* Bodies are not enforced to be immutable, as they can include a reference to any
* user-defined data type. However, interceptors should take care to preserve
* idempotence by treating them as such.
*/
this.body = null;
/**
* Whether this request should be made in a way that exposes progress events.
*
* Progress events are expensive (change detection runs on each event) and so
* they should only be requested if the consumer intends to monitor them.
*
* Note: The `FetchBackend` doesn't support progress report on uploads.
*/
this.reportProgress = false;
/**
* Whether this request should be sent with outgoing credentials (cookies).
*/
this.withCredentials = false;
/**
* The expected response type of the server.
*
* This is used to parse the response appropriately before returning it to
* the requestee.
*/
this.responseType = 'json';
this.method = method.toUpperCase();
// Next, need to figure out which argument holds the HttpRequestInit
// options, if any.
let options;
// Check whether a body argument is expected. The only valid way to omit
// the body argument is to use a known no-body method like GET.
if (mightHaveBody(this.method) || !!fourth) {
// Body is the third argument, options are the fourth.
this.body = third !== undefined ? third : null;
options = fourth;
}
else {
// No body required, options are the third argument. The body stays null.
options = third;
}
// If options have been passed, interpret them.
if (options) {
// Normalize reportProgress and withCredentials.
this.reportProgress = !!options.reportProgress;
this.withCredentials = !!options.withCredentials;
// Override default response type of 'json' if one is provided.
if (!!options.responseType) {
this.responseType = options.responseType;
}
// Override headers if they're provided.
if (!!options.headers) {
this.headers = options.headers;
}
if (!!options.context) {
this.context = options.context;
}
if (!!options.params) {
this.params = options.params;
}
// We do want to assign transferCache even if it's falsy (false is valid value)
this.transferCache = options.transferCache;
}
// If no headers have been passed in, construct a new HttpHeaders instance.
this.headers ??= new HttpHeaders();
// If no context have been passed in, construct a new HttpContext instance.
this.context ??= new HttpContext();
// If no parameters have been passed in, construct a new HttpUrlEncodedParams instance.
if (!this.params) {
this.params = new HttpParams();
this.urlWithParams = url;
}
else {
// Encode the parameters to a string in preparation for inclusion in the URL.
const params = this.params.toString();
if (params.length === 0) {
// No parameters, the visible URL is just the URL given at creation time.
this.urlWithParams = url;
}
else {
// Does the URL already have query parameters? Look for '?'.
const qIdx = url.indexOf('?');
// There are 3 cases to handle:
// 1) No existing parameters -> append '?' followed by params.
// 2) '?' exists and is followed by existing query string ->
// append '&' followed by params.
// 3) '?' exists at the end of the url -> append params directly.
// This basically amounts to determining the character, if any, with
// which to join the URL and parameters.
const sep = qIdx === -1 ? '?' : qIdx < url.length - 1 ? '&' : '';
this.urlWithParams = url + sep + params;
}
}
}
/**
* Transform the free-form body into a serialized format suitable for
* transmission to the server.
*/
serializeBody() {
// If no body is present, no need to serialize it.
if (this.body === null) {
return null;
}
// Check whether the body is already in a serialized form. If so,
// it can just be returned directly.
if (typeof this.body === 'string' ||
isArrayBuffer(this.body) ||
isBlob(this.body) ||
isFormData(this.body) ||
isUrlSearchParams(this.body)) {
return this.body;
}
// Check whether the body is an instance of HttpUrlEncodedParams.
if (this.body instanceof HttpParams) {
return this.body.toString();
}
// Check whether the body is an object or array, and serialize with JSON if so.
if (typeof this.body === 'object' ||
typeof this.body === 'boolean' ||
Array.isArray(this.body)) {
return JSON.stringify(this.body);
}
// Fall back on toString() for everything else.
return this.body.toString();
}
/**
* Examine the body and attempt to infer an appropriate MIME type
* for it.
*
* If no such type can be inferred, this method will return `null`.
*/
detectContentTypeHeader() {
// An empty body has no content type.
if (this.body === null) {
return null;
}
// FormData bodies rely on the browser's content type assignment.
if (isFormData(this.body)) {
return null;
}
// Blobs usually have their own content type. If it doesn't, then
// no type can be inferred.
if (isBlob(this.body)) {
return this.body.type || null;
}
// Array buffers have unknown contents and thus no type can be inferred.
if (isArrayBuffer(this.body)) {
return null;
}
// Technically, strings could be a form of JSON data, but it's safe enough
// to assume they're plain strings.
if (typeof this.body === 'string') {
return 'text/plain';
}
// `HttpUrlEncodedParams` has its own content-type.
if (this.body instanceof HttpParams) {
return 'application/x-www-form-urlencoded;charset=UTF-8';
}
// Arrays, objects, boolean and numbers will be encoded as JSON.
if (typeof this.body === 'object' ||
typeof this.body === 'number' ||
typeof this.body === 'boolean') {
return 'application/json';
}
// No type could be inferred.
return null;
}
clone(update = {}) {
// For method, url, and responseType, take the current value unless
// it is overridden in the update hash.
const method = update.method || this.method;
const url = update.url || this.url;
const responseType = update.responseType || this.responseType;
// Carefully handle the transferCache to differentiate between
// `false` and `undefined` in the update args.
const transferCache = update.transferCache ?? this.transferCache;
// The body is somewhat special - a `null` value in update.body means
// whatever current body is present is being overridden with an empty
// body, whereas an `undefined` value in update.body implies no
// override.
const body = update.body !== undefined ? update.body : this.body;
// Carefully handle the boolean options to differentiate between
// `false` and `undefined` in the update args.
const withCredentials = update.withCredentials ?? this.withCredentials;
const reportProgress = update.reportProgress ?? this.reportProgress;
// Headers and params may be appended to if `setHeaders` or
// `setParams` are used.
let headers = update.headers || this.headers;
let params = update.params || this.params;
// Pass on context if needed
const context = update.context ?? this.context;
// Check whether the caller has asked to add headers.
if (update.setHeaders !== undefined) {
// Set every requested header.
headers = Object.keys(update.setHeaders).reduce((headers, name) => headers.set(name, update.setHeaders[name]), headers);
}
// Check whether the caller has asked to set params.
if (update.setParams) {
// Set every requested param.
params = Object.keys(update.setParams).reduce((params, param) => params.set(param, update.setParams[param]), params);
}
// Finally, construct the new HttpRequest using the pieces from above.
return new HttpRequest(method, url, body, {
params,
headers,
context,
reportProgress,
responseType,
withCredentials,
transferCache,
});
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"request.js","sourceRoot":"","sources":["../../../../../../../packages/common/http/src/request.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,WAAW,EAAC,MAAM,WAAW,CAAC;AACtC,OAAO,EAAC,WAAW,EAAC,MAAM,WAAW,CAAC;AACtC,OAAO,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AAiBpC;;GAEG;AACH,SAAS,aAAa,CAAC,MAAc;IACnC,QAAQ,MAAM,EAAE,CAAC;QACf,KAAK,QAAQ,CAAC;QACd,KAAK,KAAK,CAAC;QACX,KAAK,MAAM,CAAC;QACZ,KAAK,SAAS,CAAC;QACf,KAAK,OAAO;YACV,OAAO,KAAK,CAAC;QACf;YACE,OAAO,IAAI,CAAC;IAChB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,KAAU;IAC/B,OAAO,OAAO,WAAW,KAAK,WAAW,IAAI,KAAK,YAAY,WAAW,CAAC;AAC5E,CAAC;AAED;;;;GAIG;AACH,SAAS,MAAM,CAAC,KAAU;IACxB,OAAO,OAAO,IAAI,KAAK,WAAW,IAAI,KAAK,YAAY,IAAI,CAAC;AAC9D,CAAC;AAED;;;;GAIG;AACH,SAAS,UAAU,CAAC,KAAU;IAC5B,OAAO,OAAO,QAAQ,KAAK,WAAW,IAAI,KAAK,YAAY,QAAQ,CAAC;AACtE,CAAC;AAED;;;;GAIG;AACH,SAAS,iBAAiB,CAAC,KAAU;IACnC,OAAO,OAAO,eAAe,KAAK,WAAW,IAAI,KAAK,YAAY,eAAe,CAAC;AACpF,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,OAAO,WAAW;IAkKtB,YACE,MAAc,EACL,GAAW,EACpB,KAWQ,EACR,MAQC;QArBQ,QAAG,GAAH,GAAG,CAAQ;QAnKtB;;;;;;WAMG;QACM,SAAI,GAAa,IAAI,CAAC;QAa/B;;;;;;;WAOG;QACM,mBAAc,GAAY,KAAK,CAAC;QAEzC;;WAEG;QACM,oBAAe,GAAY,KAAK,CAAC;QAE1C;;;;;WAKG;QACM,iBAAY,GAA6C,MAAM,CAAC;QAiJvE,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC;QACnC,oEAAoE;QACpE,mBAAmB;QACnB,IAAI,OAAoC,CAAC;QAEzC,wEAAwE;QACxE,+DAA+D;QAC/D,IAAI,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;YAC3C,sDAAsD;YACtD,IAAI,CAAC,IAAI,GAAG,KAAK,KAAK,SAAS,CAAC,CAAC,CAAE,KAAW,CAAC,CAAC,CAAC,IAAI,CAAC;YACtD,OAAO,GAAG,MAAM,CAAC;QACnB,CAAC;aAAM,CAAC;YACN,yEAAyE;YACzE,OAAO,GAAG,KAAwB,CAAC;QACrC,CAAC;QAED,+CAA+C;QAC/C,IAAI,OAAO,EAAE,CAAC;YACZ,gDAAgD;YAChD,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC;YAC/C,IAAI,CAAC,eAAe,GAAG,CAAC,CAAC,OAAO,CAAC,eAAe,CAAC;YAEjD,+DAA+D;YAC/D,IAAI,CAAC,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;gBAC3B,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;YAC3C,CAAC;YAED,wCAAwC;YACxC,IAAI,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;gBACtB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;YACjC,CAAC;YAED,IAAI,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;gBACtB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;YACjC,CAAC;YAED,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;gBACrB,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;YAC/B,CAAC;YAED,+EAA+E;YAC/E,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;QAC7C,CAAC;QAED,2EAA2E;QAC3E,IAAI,CAAC,OAAO,KAAK,IAAI,WAAW,EAAE,CAAC;QAEnC,2EAA2E;QAC3E,IAAI,CAAC,OAAO,KAAK,IAAI,WAAW,EAAE,CAAC;QAEnC,uFAAuF;QACvF,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,IAAI,CAAC,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;YAC/B,IAAI,CAAC,aAAa,GAAG,GAAG,CAAC;QAC3B,CAAC;aAAM,CAAC;YACN,6EAA6E;YAC7E,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACtC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACxB,yEAAyE;gBACzE,IAAI,CAAC,aAAa,GAAG,GAAG,CAAC;YAC3B,CAAC;iBAAM,CAAC;gBACN,4DAA4D;gBAC5D,MAAM,IAAI,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;gBAC9B,+BAA+B;gBAC/B,8DAA8D;gBAC9D,4DAA4D;gBAC5D,oCAAoC;gBACpC,iEAAiE;gBACjE,oEAAoE;gBACpE,wCAAwC;gBACxC,MAAM,GAAG,GAAW,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;gBACzE,IAAI,CAAC,aAAa,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,CAAC;YAC1C,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,aAAa;QACX,kDAAkD;QAClD,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YACvB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,iEAAiE;QACjE,oCAAoC;QACpC,IACE,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ;YAC7B,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC;YACxB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;YACjB,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC;YACrB,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,EAC5B,CAAC;YACD,OAAO,IAAI,CAAC,IAAI,CAAC;QACnB,CAAC;QACD,iEAAiE;QACjE,IAAI,IAAI,CAAC,IAAI,YAAY,UAAU,EAAE,CAAC;YACpC,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC9B,CAAC;QACD,+EAA+E;QAC/E,IACE,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ;YAC7B,OAAO,IAAI,CAAC,IAAI,KAAK,SAAS;YAC9B,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EACxB,CAAC;YACD,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnC,CAAC;QACD,+CAA+C;QAC/C,OAAQ,IAAI,CAAC,IAAY,CAAC,QAAQ,EAAE,CAAC;IACvC,CAAC;IAED;;;;;OAKG;IACH,uBAAuB;QACrB,qCAAqC;QACrC,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YACvB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,iEAAiE;QACjE,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAC1B,OAAO,IAAI,CAAC;QACd,CAAC;QACD,iEAAiE;QACjE,2BAA2B;QAC3B,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YACtB,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;QAChC,CAAC;QACD,wEAAwE;QACxE,IAAI,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC;QACd,CAAC;QACD,0EAA0E;QAC1E,mCAAmC;QACnC,IAAI,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAClC,OAAO,YAAY,CAAC;QACtB,CAAC;QACD,mDAAmD;QACnD,IAAI,IAAI,CAAC,IAAI,YAAY,UAAU,EAAE,CAAC;YACpC,OAAO,iDAAiD,CAAC;QAC3D,CAAC;QACD,gEAAgE;QAChE,IACE,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ;YAC7B,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ;YAC7B,OAAO,IAAI,CAAC,IAAI,KAAK,SAAS,EAC9B,CAAC;YACD,OAAO,kBAAkB,CAAC;QAC5B,CAAC;QACD,6BAA6B;QAC7B,OAAO,IAAI,CAAC;IACd,CAAC;IA+BD,KAAK,CACH,SAaI,EAAE;QAEN,mEAAmE;QACnE,uCAAuC;QACvC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC;QAC5C,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC;QACnC,MAAM,YAAY,GAAG,MAAM,CAAC,YAAY,IAAI,IAAI,CAAC,YAAY,CAAC;QAE9D,8DAA8D;QAC9D,8CAA8C;QAC9C,MAAM,aAAa,GAAG,MAAM,CAAC,aAAa,IAAI,IAAI,CAAC,aAAa,CAAC;QAEjE,qEAAqE;QACrE,qEAAqE;QACrE,+DAA+D;QAC/D,YAAY;QACZ,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QAEjE,gEAAgE;QAChE,8CAA8C;QAC9C,MAAM,eAAe,GAAG,MAAM,CAAC,eAAe,IAAI,IAAI,CAAC,eAAe,CAAC;QACvE,MAAM,cAAc,GAAG,MAAM,CAAC,cAAc,IAAI,IAAI,CAAC,cAAc,CAAC;QAEpE,2DAA2D;QAC3D,wBAAwB;QACxB,IAAI,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;QAC7C,IAAI,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC;QAE1C,4BAA4B;QAC5B,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;QAE/C,qDAAqD;QACrD,IAAI,MAAM,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;YACpC,8BAA8B;YAC9B,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,MAAM,CAC7C,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,UAAW,CAAC,IAAI,CAAC,CAAC,EAC9D,OAAO,CACR,CAAC;QACJ,CAAC;QAED,oDAAoD;QACpD,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;YACrB,6BAA6B;YAC7B,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM,CAC3C,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,SAAU,CAAC,KAAK,CAAC,CAAC,EAC9D,MAAM,CACP,CAAC;QACJ,CAAC;QAED,sEAAsE;QACtE,OAAO,IAAI,WAAW,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE;YACxC,MAAM;YACN,OAAO;YACP,OAAO;YACP,cAAc;YACd,YAAY;YACZ,eAAe;YACf,aAAa;SACd,CAAC,CAAC;IACL,CAAC;CACF","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 {HttpContext} from './context';\nimport {HttpHeaders} from './headers';\nimport {HttpParams} from './params';\n\n/**\n * Construction interface for `HttpRequest`s.\n *\n * All values are optional and will override default values if provided.\n */\ninterface HttpRequestInit {\n  headers?: HttpHeaders;\n  context?: HttpContext;\n  reportProgress?: boolean;\n  params?: HttpParams;\n  responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n  withCredentials?: boolean;\n  transferCache?: {includeHeaders?: string[]} | boolean;\n}\n\n/**\n * Determine whether the given HTTP method may include a body.\n */\nfunction mightHaveBody(method: string): boolean {\n  switch (method) {\n    case 'DELETE':\n    case 'GET':\n    case 'HEAD':\n    case 'OPTIONS':\n    case 'JSONP':\n      return false;\n    default:\n      return true;\n  }\n}\n\n/**\n * Safely assert whether the given value is an ArrayBuffer.\n *\n * In some execution environments ArrayBuffer is not defined.\n */\nfunction isArrayBuffer(value: any): value is ArrayBuffer {\n  return typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer;\n}\n\n/**\n * Safely assert whether the given value is a Blob.\n *\n * In some execution environments Blob is not defined.\n */\nfunction isBlob(value: any): value is Blob {\n  return typeof Blob !== 'undefined' && value instanceof Blob;\n}\n\n/**\n * Safely assert whether the given value is a FormData instance.\n *\n * In some execution environments FormData is not defined.\n */\nfunction isFormData(value: any): value is FormData {\n  return typeof FormData !== 'undefined' && value instanceof FormData;\n}\n\n/**\n * Safely assert whether the given value is a URLSearchParams instance.\n *\n * In some execution environments URLSearchParams is not defined.\n */\nfunction isUrlSearchParams(value: any): value is URLSearchParams {\n  return typeof URLSearchParams !== 'undefined' && value instanceof URLSearchParams;\n}\n\n/**\n * An outgoing HTTP request with an optional typed body.\n *\n * `HttpRequest` represents an outgoing request, including URL, method,\n * headers, body, and other request configuration options. Instances should be\n * assumed to be immutable. To modify a `HttpRequest`, the `clone`\n * method should be used.\n *\n * @publicApi\n */\nexport class HttpRequest<T> {\n  /**\n   * The request body, or `null` if one isn't set.\n   *\n   * Bodies are not enforced to be immutable, as they can include a reference to any\n   * user-defined data type. However, interceptors should take care to preserve\n   * idempotence by treating them as such.\n   */\n  readonly body: T | null = null;\n\n  /**\n   * Outgoing headers for this request.\n   */\n  // TODO(issue/24571): remove '!'.\n  readonly headers!: HttpHeaders;\n\n  /**\n   * Shared and mutable context that can be used by interceptors\n   */\n  readonly context!: HttpContext;\n\n  /**\n   * Whether this request should be made in a way that exposes progress events.\n   *\n   * Progress events are expensive (change detection runs on each event) and so\n   * they should only be requested if the consumer intends to monitor them.\n   *\n   * Note: The `FetchBackend` doesn't support progress report on uploads.\n   */\n  readonly reportProgress: boolean = false;\n\n  /**\n   * Whether this request should be sent with outgoing credentials (cookies).\n   */\n  readonly withCredentials: boolean = false;\n\n  /**\n   * The expected response type of the server.\n   *\n   * This is used to parse the response appropriately before returning it to\n   * the requestee.\n   */\n  readonly responseType: 'arraybuffer' | 'blob' | 'json' | 'text' = 'json';\n\n  /**\n   * The outgoing HTTP request method.\n   */\n  readonly method: string;\n\n  /**\n   * Outgoing URL parameters.\n   *\n   * To pass a string representation of HTTP parameters in the URL-query-string format,\n   * the `HttpParamsOptions`' `fromString` may be used. For example:\n   *\n   * ```\n   * new HttpParams({fromString: 'angular=awesome'})\n   * ```\n   */\n  // TODO(issue/24571): remove '!'.\n  readonly params!: HttpParams;\n\n  /**\n   * The outgoing URL with all URL parameters set.\n   */\n  readonly urlWithParams: string;\n\n  /**\n   * The HttpTransferCache option for the request\n   */\n  readonly transferCache?: {includeHeaders?: string[]} | boolean;\n\n  constructor(\n    method: 'GET' | 'HEAD',\n    url: string,\n    init?: {\n      headers?: HttpHeaders;\n      context?: HttpContext;\n      reportProgress?: boolean;\n      params?: HttpParams;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      /**\n       * This property accepts either a boolean to enable/disable transferring cache for eligible\n       * requests performed using `HttpClient`, or an object, which allows to configure cache\n       * parameters, such as which headers should be included (no headers are included by default).\n       *\n       * Setting this property will override the options passed to `provideClientHydration()` for this\n       * particular request\n       */\n      transferCache?: {includeHeaders?: string[]} | boolean;\n    },\n  );\n  constructor(\n    method: 'DELETE' | 'JSONP' | 'OPTIONS',\n    url: string,\n    init?: {\n      headers?: HttpHeaders;\n      context?: HttpContext;\n      reportProgress?: boolean;\n      params?: HttpParams;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n    },\n  );\n  constructor(\n    method: 'POST',\n    url: string,\n    body: T | null,\n    init?: {\n      headers?: HttpHeaders;\n      context?: HttpContext;\n      reportProgress?: boolean;\n      params?: HttpParams;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      /**\n       * This property accepts either a boolean to enable/disable transferring cache for eligible\n       * requests performed using `HttpClient`, or an object, which allows to configure cache\n       * parameters, such as which headers should be included (no headers are included by default).\n       *\n       * Setting this property will override the options passed to `provideClientHydration()` for this\n       * particular request\n       */\n      transferCache?: {includeHeaders?: string[]} | boolean;\n    },\n  );\n  constructor(\n    method: 'PUT' | 'PATCH',\n    url: string,\n    body: T | null,\n    init?: {\n      headers?: HttpHeaders;\n      context?: HttpContext;\n      reportProgress?: boolean;\n      params?: HttpParams;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n    },\n  );\n  constructor(\n    method: string,\n    url: string,\n    body: T | null,\n    init?: {\n      headers?: HttpHeaders;\n      context?: HttpContext;\n      reportProgress?: boolean;\n      params?: HttpParams;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      /**\n       * This property accepts either a boolean to enable/disable transferring cache for eligible\n       * requests performed using `HttpClient`, or an object, which allows to configure cache\n       * parameters, such as which headers should be included (no headers are included by default).\n       *\n       * Setting this property will override the options passed to `provideClientHydration()` for this\n       * particular request\n       */\n      transferCache?: {includeHeaders?: string[]} | boolean;\n    },\n  );\n  constructor(\n    method: string,\n    readonly url: string,\n    third?:\n      | T\n      | {\n          headers?: HttpHeaders;\n          context?: HttpContext;\n          reportProgress?: boolean;\n          params?: HttpParams;\n          responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n          withCredentials?: boolean;\n          transferCache?: {includeHeaders?: string[]} | boolean;\n        }\n      | null,\n    fourth?: {\n      headers?: HttpHeaders;\n      context?: HttpContext;\n      reportProgress?: boolean;\n      params?: HttpParams;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      transferCache?: {includeHeaders?: string[]} | boolean;\n    },\n  ) {\n    this.method = method.toUpperCase();\n    // Next, need to figure out which argument holds the HttpRequestInit\n    // options, if any.\n    let options: HttpRequestInit | undefined;\n\n    // Check whether a body argument is expected. The only valid way to omit\n    // the body argument is to use a known no-body method like GET.\n    if (mightHaveBody(this.method) || !!fourth) {\n      // Body is the third argument, options are the fourth.\n      this.body = third !== undefined ? (third as T) : null;\n      options = fourth;\n    } else {\n      // No body required, options are the third argument. The body stays null.\n      options = third as HttpRequestInit;\n    }\n\n    // If options have been passed, interpret them.\n    if (options) {\n      // Normalize reportProgress and withCredentials.\n      this.reportProgress = !!options.reportProgress;\n      this.withCredentials = !!options.withCredentials;\n\n      // Override default response type of 'json' if one is provided.\n      if (!!options.responseType) {\n        this.responseType = options.responseType;\n      }\n\n      // Override headers if they're provided.\n      if (!!options.headers) {\n        this.headers = options.headers;\n      }\n\n      if (!!options.context) {\n        this.context = options.context;\n      }\n\n      if (!!options.params) {\n        this.params = options.params;\n      }\n\n      // We do want to assign transferCache even if it's falsy (false is valid value)\n      this.transferCache = options.transferCache;\n    }\n\n    // If no headers have been passed in, construct a new HttpHeaders instance.\n    this.headers ??= new HttpHeaders();\n\n    // If no context have been passed in, construct a new HttpContext instance.\n    this.context ??= new HttpContext();\n\n    // If no parameters have been passed in, construct a new HttpUrlEncodedParams instance.\n    if (!this.params) {\n      this.params = new HttpParams();\n      this.urlWithParams = url;\n    } else {\n      // Encode the parameters to a string in preparation for inclusion in the URL.\n      const params = this.params.toString();\n      if (params.length === 0) {\n        // No parameters, the visible URL is just the URL given at creation time.\n        this.urlWithParams = url;\n      } else {\n        // Does the URL already have query parameters? Look for '?'.\n        const qIdx = url.indexOf('?');\n        // There are 3 cases to handle:\n        // 1) No existing parameters -> append '?' followed by params.\n        // 2) '?' exists and is followed by existing query string ->\n        //    append '&' followed by params.\n        // 3) '?' exists at the end of the url -> append params directly.\n        // This basically amounts to determining the character, if any, with\n        // which to join the URL and parameters.\n        const sep: string = qIdx === -1 ? '?' : qIdx < url.length - 1 ? '&' : '';\n        this.urlWithParams = url + sep + params;\n      }\n    }\n  }\n\n  /**\n   * Transform the free-form body into a serialized format suitable for\n   * transmission to the server.\n   */\n  serializeBody(): ArrayBuffer | Blob | FormData | URLSearchParams | string | null {\n    // If no body is present, no need to serialize it.\n    if (this.body === null) {\n      return null;\n    }\n    // Check whether the body is already in a serialized form. If so,\n    // it can just be returned directly.\n    if (\n      typeof this.body === 'string' ||\n      isArrayBuffer(this.body) ||\n      isBlob(this.body) ||\n      isFormData(this.body) ||\n      isUrlSearchParams(this.body)\n    ) {\n      return this.body;\n    }\n    // Check whether the body is an instance of HttpUrlEncodedParams.\n    if (this.body instanceof HttpParams) {\n      return this.body.toString();\n    }\n    // Check whether the body is an object or array, and serialize with JSON if so.\n    if (\n      typeof this.body === 'object' ||\n      typeof this.body === 'boolean' ||\n      Array.isArray(this.body)\n    ) {\n      return JSON.stringify(this.body);\n    }\n    // Fall back on toString() for everything else.\n    return (this.body as any).toString();\n  }\n\n  /**\n   * Examine the body and attempt to infer an appropriate MIME type\n   * for it.\n   *\n   * If no such type can be inferred, this method will return `null`.\n   */\n  detectContentTypeHeader(): string | null {\n    // An empty body has no content type.\n    if (this.body === null) {\n      return null;\n    }\n    // FormData bodies rely on the browser's content type assignment.\n    if (isFormData(this.body)) {\n      return null;\n    }\n    // Blobs usually have their own content type. If it doesn't, then\n    // no type can be inferred.\n    if (isBlob(this.body)) {\n      return this.body.type || null;\n    }\n    // Array buffers have unknown contents and thus no type can be inferred.\n    if (isArrayBuffer(this.body)) {\n      return null;\n    }\n    // Technically, strings could be a form of JSON data, but it's safe enough\n    // to assume they're plain strings.\n    if (typeof this.body === 'string') {\n      return 'text/plain';\n    }\n    // `HttpUrlEncodedParams` has its own content-type.\n    if (this.body instanceof HttpParams) {\n      return 'application/x-www-form-urlencoded;charset=UTF-8';\n    }\n    // Arrays, objects, boolean and numbers will be encoded as JSON.\n    if (\n      typeof this.body === 'object' ||\n      typeof this.body === 'number' ||\n      typeof this.body === 'boolean'\n    ) {\n      return 'application/json';\n    }\n    // No type could be inferred.\n    return null;\n  }\n\n  clone(): HttpRequest<T>;\n  clone(update: {\n    headers?: HttpHeaders;\n    context?: HttpContext;\n    reportProgress?: boolean;\n    params?: HttpParams;\n    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n    withCredentials?: boolean;\n    transferCache?: {includeHeaders?: string[]} | boolean;\n    body?: T | null;\n    method?: string;\n    url?: string;\n    setHeaders?: {[name: string]: string | string[]};\n    setParams?: {[param: string]: string};\n  }): HttpRequest<T>;\n  clone<V>(update: {\n    headers?: HttpHeaders;\n    context?: HttpContext;\n    reportProgress?: boolean;\n    params?: HttpParams;\n    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n    withCredentials?: boolean;\n    transferCache?: {includeHeaders?: string[]} | boolean;\n    body?: V | null;\n    method?: string;\n    url?: string;\n    setHeaders?: {[name: string]: string | string[]};\n    setParams?: {[param: string]: string};\n  }): HttpRequest<V>;\n  clone(\n    update: {\n      headers?: HttpHeaders;\n      context?: HttpContext;\n      reportProgress?: boolean;\n      params?: HttpParams;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      transferCache?: {includeHeaders?: string[]} | boolean;\n      body?: any | null;\n      method?: string;\n      url?: string;\n      setHeaders?: {[name: string]: string | string[]};\n      setParams?: {[param: string]: string};\n    } = {},\n  ): HttpRequest<any> {\n    // For method, url, and responseType, take the current value unless\n    // it is overridden in the update hash.\n    const method = update.method || this.method;\n    const url = update.url || this.url;\n    const responseType = update.responseType || this.responseType;\n\n    // Carefully handle the transferCache to differentiate between\n    // `false` and `undefined` in the update args.\n    const transferCache = update.transferCache ?? this.transferCache;\n\n    // The body is somewhat special - a `null` value in update.body means\n    // whatever current body is present is being overridden with an empty\n    // body, whereas an `undefined` value in update.body implies no\n    // override.\n    const body = update.body !== undefined ? update.body : this.body;\n\n    // Carefully handle the boolean options to differentiate between\n    // `false` and `undefined` in the update args.\n    const withCredentials = update.withCredentials ?? this.withCredentials;\n    const reportProgress = update.reportProgress ?? this.reportProgress;\n\n    // Headers and params may be appended to if `setHeaders` or\n    // `setParams` are used.\n    let headers = update.headers || this.headers;\n    let params = update.params || this.params;\n\n    // Pass on context if needed\n    const context = update.context ?? this.context;\n\n    // Check whether the caller has asked to add headers.\n    if (update.setHeaders !== undefined) {\n      // Set every requested header.\n      headers = Object.keys(update.setHeaders).reduce(\n        (headers, name) => headers.set(name, update.setHeaders![name]),\n        headers,\n      );\n    }\n\n    // Check whether the caller has asked to set params.\n    if (update.setParams) {\n      // Set every requested param.\n      params = Object.keys(update.setParams).reduce(\n        (params, param) => params.set(param, update.setParams![param]),\n        params,\n      );\n    }\n\n    // Finally, construct the new HttpRequest using the pieces from above.\n    return new HttpRequest(method, url, body, {\n      params,\n      headers,\n      context,\n      reportProgress,\n      responseType,\n      withCredentials,\n      transferCache,\n    });\n  }\n}\n"]}