@angular/common
Version:
Angular - commonly needed directives and services
243 lines • 28.9 kB
JavaScript
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { inject, InjectionToken, makeEnvironmentProviders } from '@angular/core';
import { HttpBackend, HttpHandler } from './backend';
import { HttpClient } from './client';
import { FetchBackend } from './fetch';
import { HTTP_INTERCEPTOR_FNS, HttpInterceptorHandler, legacyInterceptorFnFactory, PRIMARY_HTTP_BACKEND } from './interceptor';
import { jsonpCallbackContext, JsonpCallbackContext, JsonpClientBackend, jsonpInterceptorFn } from './jsonp';
import { HttpXhrBackend } from './xhr';
import { HttpXsrfCookieExtractor, HttpXsrfTokenExtractor, XSRF_COOKIE_NAME, XSRF_ENABLED, XSRF_HEADER_NAME, xsrfInterceptorFn } from './xsrf';
/**
* Identifies a particular kind of `HttpFeature`.
*
* @publicApi
*/
export 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 = {}));
function makeHttpFeature(kind, providers) {
return {
ɵkind: kind,
ɵproviders: providers,
};
}
/**
* Configures Angular's `HttpClient` service to be available for injection.
*
* By default, `HttpClient` will be configured for injection with its default options for XSRF
* protection of outgoing requests. Additional configuration options can be provided by passing
* feature functions to `provideHttpClient`. For example, HTTP interceptors can be added using the
* `withInterceptors(...)` feature.
*
* <div class="alert is-helpful">
*
* It's strongly recommended to enable
* [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) for applications that use
* Server-Side Rendering for better performance and compatibility. To enable `fetch`, add
* `withFetch()` feature to the `provideHttpClient()` call at the root of the application:
*
* ```
* provideHttpClient(withFetch());
* ```
*
* </div>
*
* @see {@link withInterceptors}
* @see {@link withInterceptorsFromDi}
* @see {@link withXsrfConfiguration}
* @see {@link withNoXsrfProtection}
* @see {@link withJsonpSupport}
* @see {@link withRequestsMadeViaParent}
* @see {@link withFetch}
*/
export 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(ngDevMode ?
`Configuration error: found both withXsrfConfiguration() and withNoXsrfProtection() in the same call to provideHttpClient(), which is a contradiction.` :
'');
}
}
const providers = [
HttpClient,
HttpXhrBackend,
HttpInterceptorHandler,
{ provide: HttpHandler, useExisting: HttpInterceptorHandler },
{ provide: HttpBackend, useExisting: HttpXhrBackend },
{
provide: HTTP_INTERCEPTOR_FNS,
useValue: xsrfInterceptorFn,
multi: true,
},
{ provide: XSRF_ENABLED, useValue: true },
{ provide: HttpXsrfTokenExtractor, useClass: HttpXsrfCookieExtractor },
];
for (const feature of features) {
providers.push(...feature.ɵproviders);
}
return makeEnvironmentProviders(providers);
}
/**
* Adds one or more functional-style HTTP interceptors to the configuration of the `HttpClient`
* instance.
*
* @see {@link HttpInterceptorFn}
* @see {@link provideHttpClient}
* @publicApi
*/
export 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('LEGACY_INTERCEPTOR_FN');
/**
* Includes class-based interceptors configured using a multi-provider in the current injector into
* the configured `HttpClient` instance.
*
* Prefer `withInterceptors` and functional interceptors instead, as support for DI-provided
* interceptors may be phased out in a later release.
*
* @see {@link HttpInterceptor}
* @see {@link HTTP_INTERCEPTORS}
* @see {@link provideHttpClient}
*/
export function withInterceptorsFromDi() {
// Note: the legacy interceptor function is provided here via an intermediate token
// (`LEGACY_INTERCEPTOR_FN`), using a pattern which guarantees that if these providers are
// included multiple times, all of the multi-provider entries will have the same instance of the
// interceptor function. That way, the `HttpINterceptorHandler` will dedup them and legacy
// interceptors will not run multiple times.
return makeHttpFeature(HttpFeatureKind.LegacyInterceptors, [
{
provide: LEGACY_INTERCEPTOR_FN,
useFactory: legacyInterceptorFnFactory,
},
{
provide: HTTP_INTERCEPTOR_FNS,
useExisting: LEGACY_INTERCEPTOR_FN,
multi: true,
}
]);
}
/**
* Customizes the XSRF protection for the configuration of the current `HttpClient` instance.
*
* This feature is incompatible with the `withNoXsrfProtection` feature.
*
* @see {@link provideHttpClient}
*/
export 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);
}
/**
* Disables XSRF protection in the configuration of the current `HttpClient` instance.
*
* This feature is incompatible with the `withXsrfConfiguration` feature.
*
* @see {@link provideHttpClient}
*/
export function withNoXsrfProtection() {
return makeHttpFeature(HttpFeatureKind.NoXsrfProtection, [
{
provide: XSRF_ENABLED,
useValue: false,
},
]);
}
/**
* Add JSONP support to the configuration of the current `HttpClient` instance.
*
* @see {@link provideHttpClient}
*/
export function withJsonpSupport() {
return makeHttpFeature(HttpFeatureKind.JsonpSupport, [
JsonpClientBackend,
{ provide: JsonpCallbackContext, useFactory: jsonpCallbackContext },
{ provide: HTTP_INTERCEPTOR_FNS, useValue: jsonpInterceptorFn, multi: true },
]);
}
/**
* Configures the current `HttpClient` instance to make requests via the parent injector's
* `HttpClient` instead of directly.
*
* By default, `provideHttpClient` configures `HttpClient` in its injector to be an independent
* instance. For example, even if `HttpClient` is configured in the parent injector with
* one or more interceptors, they will not intercept requests made via this instance.
*
* With this option enabled, once the request has passed through the current injector's
* interceptors, it will be delegated to the parent injector's `HttpClient` chain instead of
* dispatched directly, and interceptors in the parent configuration will be applied to the request.
*
* If there are several `HttpClient` instances in the injector hierarchy, it's possible for
* `withRequestsMadeViaParent` to be used at multiple levels, which will cause the request to
* "bubble up" until either reaching the root level or an `HttpClient` which was not configured with
* this option.
*
* @see {@link provideHttpClient}
* @developerPreview
*/
export 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;
},
},
]);
}
/**
* Configures the current `HttpClient` instance to make requests using the fetch API.
*
* This `FetchBackend` requires the support of the Fetch API which is available on all evergreen
* browsers and on NodeJS from v18 onward.
*
* Note: The Fetch API doesn't support progress report on uploads.
*
* @publicApi
*/
export function withFetch() {
if ((typeof ngDevMode === 'undefined' || ngDevMode) && typeof fetch !== 'function') {
// TODO: Create a runtime error
// TODO: Use ENVIRONMENT_INITIALIZER to contextualize the error message (browser or server)
throw new Error('The `withFetch` feature of HttpClient requires the `fetch` API to be available. ' +
'If you run the code in a Node environment, make sure you use Node v18.10 or later.');
}
return makeHttpFeature(HttpFeatureKind.Fetch, [
FetchBackend,
{ provide: HttpBackend, useExisting: FetchBackend },
{ provide: PRIMARY_HTTP_BACKEND, useExisting: FetchBackend },
]);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider.js","sourceRoot":"","sources":["../../../../../../../packages/common/http/src/provider.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAuB,MAAM,EAAE,cAAc,EAAE,wBAAwB,EAAW,MAAM,eAAe,CAAC;AAE/G,OAAO,EAAC,WAAW,EAAE,WAAW,EAAC,MAAM,WAAW,CAAC;AACnD,OAAO,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AACpC,OAAO,EAAC,YAAY,EAAC,MAAM,SAAS,CAAC;AACrC,OAAO,EAAC,oBAAoB,EAAqB,sBAAsB,EAAE,0BAA0B,EAAE,oBAAoB,EAAC,MAAM,eAAe,CAAC;AAChJ,OAAO,EAAC,oBAAoB,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,kBAAkB,EAAC,MAAM,SAAS,CAAC;AAC3G,OAAO,EAAC,cAAc,EAAC,MAAM,OAAO,CAAC;AACrC,OAAO,EAAC,uBAAuB,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAC,MAAM,QAAQ,CAAC;AAE5I;;;;GAIG;AACH,MAAM,CAAN,IAAY,eAQX;AARD,WAAY,eAAe;IACzB,qEAAY,CAAA;IACZ,iFAAkB,CAAA;IAClB,2FAAuB,CAAA;IACvB,6EAAgB,CAAA;IAChB,qEAAY,CAAA;IACZ,uFAAqB,CAAA;IACrB,uDAAK,CAAA;AACP,CAAC,EARW,eAAe,KAAf,eAAe,QAQ1B;AAYD,SAAS,eAAe,CACpB,IAAW,EAAE,SAAqB;IACpC,OAAO;QACL,KAAK,EAAE,IAAI;QACX,UAAU,EAAE,SAAS;KACtB,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAG,QAAwC;IAE3E,IAAI,SAAS,EAAE,CAAC;QACd,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;QACzD,IAAI,YAAY,CAAC,GAAG,CAAC,eAAe,CAAC,gBAAgB,CAAC;YAClD,YAAY,CAAC,GAAG,CAAC,eAAe,CAAC,uBAAuB,CAAC,EAAE,CAAC;YAC9D,MAAM,IAAI,KAAK,CACX,SAAS,CAAC,CAAC;gBACP,uJAAuJ,CAAC,CAAC;gBACzJ,EAAE,CAAC,CAAC;QACd,CAAC;IACH,CAAC;IAED,MAAM,SAAS,GAAe;QAC5B,UAAU;QACV,cAAc;QACd,sBAAsB;QACtB,EAAC,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,sBAAsB,EAAC;QAC3D,EAAC,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAC;QACnD;YACE,OAAO,EAAE,oBAAoB;YAC7B,QAAQ,EAAE,iBAAiB;YAC3B,KAAK,EAAE,IAAI;SACZ;QACD,EAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAC;QACvC,EAAC,OAAO,EAAE,sBAAsB,EAAE,QAAQ,EAAE,uBAAuB,EAAC;KACrE,CAAC;IAEF,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,SAAS,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACxC,CAAC;IAED,OAAO,wBAAwB,CAAC,SAAS,CAAC,CAAC;AAC7C,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,cAAmC;IAElE,OAAO,eAAe,CAAC,eAAe,CAAC,YAAY,EAAE,cAAc,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE;QACtF,OAAO;YACL,OAAO,EAAE,oBAAoB;YAC7B,QAAQ,EAAE,aAAa;YACvB,KAAK,EAAE,IAAI;SACZ,CAAC;IACJ,CAAC,CAAC,CAAC,CAAC;AACN,CAAC;AAED,MAAM,qBAAqB,GAAG,IAAI,cAAc,CAAoB,uBAAuB,CAAC,CAAC;AAE7F;;;;;;;;;;GAUG;AACH,MAAM,UAAU,sBAAsB;IACpC,mFAAmF;IACnF,0FAA0F;IAC1F,gGAAgG;IAChG,0FAA0F;IAC1F,4CAA4C;IAC5C,OAAO,eAAe,CAAC,eAAe,CAAC,kBAAkB,EAAE;QACzD;YACE,OAAO,EAAE,qBAAqB;YAC9B,UAAU,EAAE,0BAA0B;SACvC;QACD;YACE,OAAO,EAAE,oBAAoB;YAC7B,WAAW,EAAE,qBAAqB;YAClC,KAAK,EAAE,IAAI;SACZ;KACF,CAAC,CAAC;AACL,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CACjC,EAAC,UAAU,EAAE,UAAU,EAA6C;IAEtE,MAAM,SAAS,GAAe,EAAE,CAAC;IACjC,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,SAAS,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,UAAU,EAAC,CAAC,CAAC;IACpE,CAAC;IACD,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,SAAS,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,UAAU,EAAC,CAAC,CAAC;IACpE,CAAC;IAED,OAAO,eAAe,CAAC,eAAe,CAAC,uBAAuB,EAAE,SAAS,CAAC,CAAC;AAC7E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO,eAAe,CAAC,eAAe,CAAC,gBAAgB,EAAE;QACvD;YACE,OAAO,EAAE,YAAY;YACrB,QAAQ,EAAE,KAAK;SAChB;KACF,CAAC,CAAC;AACL,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO,eAAe,CAAC,eAAe,CAAC,YAAY,EAAE;QACnD,kBAAkB;QAClB,EAAC,OAAO,EAAE,oBAAoB,EAAE,UAAU,EAAE,oBAAoB,EAAC;QACjE,EAAC,OAAO,EAAE,oBAAoB,EAAE,QAAQ,EAAE,kBAAkB,EAAE,KAAK,EAAE,IAAI,EAAC;KAC3E,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,yBAAyB;IACvC,OAAO,eAAe,CAAC,eAAe,CAAC,qBAAqB,EAAE;QAC5D;YACE,OAAO,EAAE,WAAW;YACpB,UAAU,EAAE,GAAG,EAAE;gBACf,MAAM,iBAAiB,GAAG,MAAM,CAAC,WAAW,EAAE,EAAC,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;gBAChF,IAAI,SAAS,IAAI,iBAAiB,KAAK,IAAI,EAAE,CAAC;oBAC5C,MAAM,IAAI,KAAK,CACX,kGAAkG,CAAC,CAAC;gBAC1G,CAAC;gBACD,OAAO,iBAAiB,CAAC;YAC3B,CAAC;SACF;KACF,CAAC,CAAC;AACL,CAAC;AAGD;;;;;;;;;GASG;AACH,MAAM,UAAU,SAAS;IACvB,IAAI,CAAC,OAAO,SAAS,KAAK,WAAW,IAAI,SAAS,CAAC,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;QACnF,+BAA+B;QAC/B,2FAA2F;QAC3F,MAAM,IAAI,KAAK,CACX,kFAAkF;YAClF,oFAAoF,CAAC,CAAC;IAC5F,CAAC;IAED,OAAO,eAAe,CAAC,eAAe,CAAC,KAAK,EAAE;QAC5C,YAAY;QACZ,EAAC,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAC;QACjD,EAAC,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,YAAY,EAAC;KAC3D,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {EnvironmentProviders, inject, InjectionToken, makeEnvironmentProviders, Provider} from '@angular/core';\n\nimport {HttpBackend, HttpHandler} from './backend';\nimport {HttpClient} from './client';\nimport {FetchBackend} from './fetch';\nimport {HTTP_INTERCEPTOR_FNS, HttpInterceptorFn, HttpInterceptorHandler, legacyInterceptorFnFactory, PRIMARY_HTTP_BACKEND} from './interceptor';\nimport {jsonpCallbackContext, JsonpCallbackContext, JsonpClientBackend, jsonpInterceptorFn} from './jsonp';\nimport {HttpXhrBackend} from './xhr';\nimport {HttpXsrfCookieExtractor, HttpXsrfTokenExtractor, XSRF_COOKIE_NAME, XSRF_ENABLED, XSRF_HEADER_NAME, xsrfInterceptorFn} from './xsrf';\n\n/**\n * Identifies a particular kind of `HttpFeature`.\n *\n * @publicApi\n */\nexport enum HttpFeatureKind {\n  Interceptors,\n  LegacyInterceptors,\n  CustomXsrfConfiguration,\n  NoXsrfProtection,\n  JsonpSupport,\n  RequestsMadeViaParent,\n  Fetch,\n}\n\n/**\n * A feature for use when configuring `provideHttpClient`.\n *\n * @publicApi\n */\nexport interface HttpFeature<KindT extends HttpFeatureKind> {\n  ɵkind: KindT;\n  ɵproviders: Provider[];\n}\n\nfunction makeHttpFeature<KindT extends HttpFeatureKind>(\n    kind: KindT, providers: Provider[]): HttpFeature<KindT> {\n  return {\n    ɵkind: kind,\n    ɵproviders: providers,\n  };\n}\n\n/**\n * Configures Angular's `HttpClient` service to be available for injection.\n *\n * By default, `HttpClient` will be configured for injection with its default options for XSRF\n * protection of outgoing requests. Additional configuration options can be provided by passing\n * feature functions to `provideHttpClient`. For example, HTTP interceptors can be added using the\n * `withInterceptors(...)` feature.\n *\n * <div class=\"alert is-helpful\">\n *\n * It's strongly recommended to enable\n * [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) for applications that use\n * Server-Side Rendering for better performance and compatibility. To enable `fetch`, add\n * `withFetch()` feature to the `provideHttpClient()` call at the root of the application:\n *\n * ```\n * provideHttpClient(withFetch());\n * ```\n *\n * </div>\n *\n * @see {@link withInterceptors}\n * @see {@link withInterceptorsFromDi}\n * @see {@link withXsrfConfiguration}\n * @see {@link withNoXsrfProtection}\n * @see {@link withJsonpSupport}\n * @see {@link withRequestsMadeViaParent}\n * @see {@link withFetch}\n */\nexport function provideHttpClient(...features: HttpFeature<HttpFeatureKind>[]):\n    EnvironmentProviders {\n  if (ngDevMode) {\n    const featureKinds = new Set(features.map(f => f.ɵkind));\n    if (featureKinds.has(HttpFeatureKind.NoXsrfProtection) &&\n        featureKinds.has(HttpFeatureKind.CustomXsrfConfiguration)) {\n      throw new Error(\n          ngDevMode ?\n              `Configuration error: found both withXsrfConfiguration() and withNoXsrfProtection() in the same call to provideHttpClient(), which is a contradiction.` :\n              '');\n    }\n  }\n\n  const providers: Provider[] = [\n    HttpClient,\n    HttpXhrBackend,\n    HttpInterceptorHandler,\n    {provide: HttpHandler, useExisting: HttpInterceptorHandler},\n    {provide: HttpBackend, useExisting: HttpXhrBackend},\n    {\n      provide: HTTP_INTERCEPTOR_FNS,\n      useValue: xsrfInterceptorFn,\n      multi: true,\n    },\n    {provide: XSRF_ENABLED, useValue: true},\n    {provide: HttpXsrfTokenExtractor, useClass: HttpXsrfCookieExtractor},\n  ];\n\n  for (const feature of features) {\n    providers.push(...feature.ɵproviders);\n  }\n\n  return makeEnvironmentProviders(providers);\n}\n\n/**\n * Adds one or more functional-style HTTP interceptors to the configuration of the `HttpClient`\n * instance.\n *\n * @see {@link HttpInterceptorFn}\n * @see {@link provideHttpClient}\n * @publicApi\n */\nexport function withInterceptors(interceptorFns: HttpInterceptorFn[]):\n    HttpFeature<HttpFeatureKind.Interceptors> {\n  return makeHttpFeature(HttpFeatureKind.Interceptors, interceptorFns.map(interceptorFn => {\n    return {\n      provide: HTTP_INTERCEPTOR_FNS,\n      useValue: interceptorFn,\n      multi: true,\n    };\n  }));\n}\n\nconst LEGACY_INTERCEPTOR_FN = new InjectionToken<HttpInterceptorFn>('LEGACY_INTERCEPTOR_FN');\n\n/**\n * Includes class-based interceptors configured using a multi-provider in the current injector into\n * the configured `HttpClient` instance.\n *\n * Prefer `withInterceptors` and functional interceptors instead, as support for DI-provided\n * interceptors may be phased out in a later release.\n *\n * @see {@link HttpInterceptor}\n * @see {@link HTTP_INTERCEPTORS}\n * @see {@link provideHttpClient}\n */\nexport function withInterceptorsFromDi(): HttpFeature<HttpFeatureKind.LegacyInterceptors> {\n  // Note: the legacy interceptor function is provided here via an intermediate token\n  // (`LEGACY_INTERCEPTOR_FN`), using a pattern which guarantees that if these providers are\n  // included multiple times, all of the multi-provider entries will have the same instance of the\n  // interceptor function. That way, the `HttpINterceptorHandler` will dedup them and legacy\n  // interceptors will not run multiple times.\n  return makeHttpFeature(HttpFeatureKind.LegacyInterceptors, [\n    {\n      provide: LEGACY_INTERCEPTOR_FN,\n      useFactory: legacyInterceptorFnFactory,\n    },\n    {\n      provide: HTTP_INTERCEPTOR_FNS,\n      useExisting: LEGACY_INTERCEPTOR_FN,\n      multi: true,\n    }\n  ]);\n}\n\n/**\n * Customizes the XSRF protection for the configuration of the current `HttpClient` instance.\n *\n * This feature is incompatible with the `withNoXsrfProtection` feature.\n *\n * @see {@link provideHttpClient}\n */\nexport function withXsrfConfiguration(\n    {cookieName, headerName}: {cookieName?: string, headerName?: string}):\n    HttpFeature<HttpFeatureKind.CustomXsrfConfiguration> {\n  const providers: Provider[] = [];\n  if (cookieName !== undefined) {\n    providers.push({provide: XSRF_COOKIE_NAME, useValue: cookieName});\n  }\n  if (headerName !== undefined) {\n    providers.push({provide: XSRF_HEADER_NAME, useValue: headerName});\n  }\n\n  return makeHttpFeature(HttpFeatureKind.CustomXsrfConfiguration, providers);\n}\n\n/**\n * Disables XSRF protection in the configuration of the current `HttpClient` instance.\n *\n * This feature is incompatible with the `withXsrfConfiguration` feature.\n *\n * @see {@link provideHttpClient}\n */\nexport function withNoXsrfProtection(): HttpFeature<HttpFeatureKind.NoXsrfProtection> {\n  return makeHttpFeature(HttpFeatureKind.NoXsrfProtection, [\n    {\n      provide: XSRF_ENABLED,\n      useValue: false,\n    },\n  ]);\n}\n\n/**\n * Add JSONP support to the configuration of the current `HttpClient` instance.\n *\n * @see {@link provideHttpClient}\n */\nexport function withJsonpSupport(): HttpFeature<HttpFeatureKind.JsonpSupport> {\n  return makeHttpFeature(HttpFeatureKind.JsonpSupport, [\n    JsonpClientBackend,\n    {provide: JsonpCallbackContext, useFactory: jsonpCallbackContext},\n    {provide: HTTP_INTERCEPTOR_FNS, useValue: jsonpInterceptorFn, multi: true},\n  ]);\n}\n\n/**\n * Configures the current `HttpClient` instance to make requests via the parent injector's\n * `HttpClient` instead of directly.\n *\n * By default, `provideHttpClient` configures `HttpClient` in its injector to be an independent\n * instance. For example, even if `HttpClient` is configured in the parent injector with\n * one or more interceptors, they will not intercept requests made via this instance.\n *\n * With this option enabled, once the request has passed through the current injector's\n * interceptors, it will be delegated to the parent injector's `HttpClient` chain instead of\n * dispatched directly, and interceptors in the parent configuration will be applied to the request.\n *\n * If there are several `HttpClient` instances in the injector hierarchy, it's possible for\n * `withRequestsMadeViaParent` to be used at multiple levels, which will cause the request to\n * \"bubble up\" until either reaching the root level or an `HttpClient` which was not configured with\n * this option.\n *\n * @see {@link provideHttpClient}\n * @developerPreview\n */\nexport function withRequestsMadeViaParent(): HttpFeature<HttpFeatureKind.RequestsMadeViaParent> {\n  return makeHttpFeature(HttpFeatureKind.RequestsMadeViaParent, [\n    {\n      provide: HttpBackend,\n      useFactory: () => {\n        const handlerFromParent = inject(HttpHandler, {skipSelf: true, optional: true});\n        if (ngDevMode && handlerFromParent === null) {\n          throw new Error(\n              'withRequestsMadeViaParent() can only be used when the parent injector also configures HttpClient');\n        }\n        return handlerFromParent;\n      },\n    },\n  ]);\n}\n\n\n/**\n * Configures the current `HttpClient` instance to make requests using the fetch API.\n *\n * This `FetchBackend` requires the support of the Fetch API which is available on all evergreen\n * browsers and on NodeJS from v18 onward.\n *\n * Note: The Fetch API doesn't support progress report on uploads.\n *\n * @publicApi\n */\nexport function withFetch(): HttpFeature<HttpFeatureKind.Fetch> {\n  if ((typeof ngDevMode === 'undefined' || ngDevMode) && typeof fetch !== 'function') {\n    // TODO: Create a runtime error\n    // TODO: Use ENVIRONMENT_INITIALIZER to contextualize the error message (browser or server)\n    throw new Error(\n        'The `withFetch` feature of HttpClient requires the `fetch` API to be available. ' +\n        'If you run the code in a Node environment, make sure you use Node v18.10 or later.');\n  }\n\n  return makeHttpFeature(HttpFeatureKind.Fetch, [\n    FetchBackend,\n    {provide: HttpBackend, useExisting: FetchBackend},\n    {provide: PRIMARY_HTTP_BACKEND, useExisting: FetchBackend},\n  ]);\n}\n"]}