238 lines
No EOL
27 KiB
JavaScript
Executable file
238 lines
No EOL
27 KiB
JavaScript
Executable file
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.dev/license
|
|
*/
|
|
import { inject, InjectionToken, makeEnvironmentProviders, } from '@angular/core';
|
|
import { HttpBackend, HttpHandler } from './backend';
|
|
import { HttpClient } from './client';
|
|
import { FetchBackend } from './fetch';
|
|
import { HTTP_INTERCEPTOR_FNS, HttpInterceptorHandler, legacyInterceptorFnFactory, } 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,
|
|
useFactory: () => {
|
|
return inject(FetchBackend, { optional: true }) ?? inject(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(ngDevMode ? '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.
|
|
*
|
|
* Note: The Fetch API doesn't support progress report on uploads.
|
|
*
|
|
* @publicApi
|
|
*/
|
|
export function withFetch() {
|
|
return makeHttpFeature(HttpFeatureKind.Fetch, [
|
|
FetchBackend,
|
|
{ provide: HttpBackend, useExisting: FetchBackend },
|
|
]);
|
|
}
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider.js","sourceRoot":"","sources":["../../../../../../../packages/common/http/src/provider.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\nimport {\n  EnvironmentProviders,\n  inject,\n  InjectionToken,\n  makeEnvironmentProviders,\n  Provider,\n} from '@angular/core';\n\nimport {HttpBackend, HttpHandler} from './backend';\nimport {HttpClient} from './client';\nimport {FetchBackend} from './fetch';\nimport {\n  HTTP_INTERCEPTOR_FNS,\n  HttpInterceptorFn,\n  HttpInterceptorHandler,\n  legacyInterceptorFnFactory,\n} from './interceptor';\nimport {\n  jsonpCallbackContext,\n  JsonpCallbackContext,\n  JsonpClientBackend,\n  jsonpInterceptorFn,\n} from './jsonp';\nimport {HttpXhrBackend} from './xhr';\nimport {\n  HttpXsrfCookieExtractor,\n  HttpXsrfTokenExtractor,\n  XSRF_COOKIE_NAME,\n  XSRF_ENABLED,\n  XSRF_HEADER_NAME,\n  xsrfInterceptorFn,\n} 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,\n  providers: Provider[],\n): 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(\n  ...features: HttpFeature<HttpFeatureKind>[]\n): EnvironmentProviders {\n  if (ngDevMode) {\n    const featureKinds = new Set(features.map((f) => f.ɵkind));\n    if (\n      featureKinds.has(HttpFeatureKind.NoXsrfProtection) &&\n      featureKinds.has(HttpFeatureKind.CustomXsrfConfiguration)\n    ) {\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\n  const providers: Provider[] = [\n    HttpClient,\n    HttpXhrBackend,\n    HttpInterceptorHandler,\n    {provide: HttpHandler, useExisting: HttpInterceptorHandler},\n    {\n      provide: HttpBackend,\n      useFactory: () => {\n        return inject(FetchBackend, {optional: true}) ?? inject(HttpXhrBackend);\n      },\n    },\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(\n  interceptorFns: HttpInterceptorFn[],\n): HttpFeature<HttpFeatureKind.Interceptors> {\n  return makeHttpFeature(\n    HttpFeatureKind.Interceptors,\n    interceptorFns.map((interceptorFn) => {\n      return {\n        provide: HTTP_INTERCEPTOR_FNS,\n        useValue: interceptorFn,\n        multi: true,\n      };\n    }),\n  );\n}\n\nconst LEGACY_INTERCEPTOR_FN = new InjectionToken<HttpInterceptorFn>(\n  ngDevMode ? 'LEGACY_INTERCEPTOR_FN' : '',\n);\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,\n  headerName,\n}: {\n  cookieName?: string;\n  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        }\n        return handlerFromParent;\n      },\n    },\n  ]);\n}\n\n/**\n * Configures the current `HttpClient` instance to make requests using the fetch API.\n *\n * Note: The Fetch API doesn't support progress report on uploads.\n *\n * @publicApi\n */\nexport function withFetch(): HttpFeature<HttpFeatureKind.Fetch> {\n  return makeHttpFeature(HttpFeatureKind.Fetch, [\n    FetchBackend,\n    {provide: HttpBackend, useExisting: FetchBackend},\n  ]);\n}\n"]}
|