• Home
• org.mvnpm.at.angular
• common
• 18.2.6
• source code
• transfer_cache.mjs

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

package.esm2022.http.src.transfer_cache.mjs Maven / Gradle / Ivy

/**
 * @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 { APP_BOOTSTRAP_LISTENER, ApplicationRef, inject, InjectionToken, makeStateKey, PLATFORM_ID, TransferState, ɵformatRuntimeError as formatRuntimeError, ɵperformanceMarkFeature as performanceMarkFeature, ɵtruncateMiddle as truncateMiddle, ɵwhenStable as whenStable, ɵRuntimeError as RuntimeError, } from '@angular/core';
import { isPlatformServer } from '@angular/common';
import { of } from 'rxjs';
import { tap } from 'rxjs/operators';
import { HttpHeaders } from './headers';
import { HTTP_ROOT_INTERCEPTOR_FNS } from './interceptor';
import { HttpResponse } from './response';
/**
 * If your application uses different HTTP origins to make API calls (via `HttpClient`) on the server and
 * on the client, the `HTTP_TRANSFER_CACHE_ORIGIN_MAP` token allows you to establish a mapping
 * between those origins, so that `HttpTransferCache` feature can recognize those requests as the same
 * ones and reuse the data cached on the server during hydration on the client.
 *
 * **Important note**: the `HTTP_TRANSFER_CACHE_ORIGIN_MAP` token should *only* be provided in
 * the *server* code of your application (typically in the `app.server.config.ts` script). Angular throws an
 * error if it detects that the token is defined while running on the client.
 *
 * @usageNotes
 *
 * When the same API endpoint is accessed via `http://internal-domain.com:8080` on the server and
 * via `https://external-domain.com` on the client, you can use the following configuration:
 * ```typescript
 * // in app.server.config.ts
 * {
 *     provide: HTTP_TRANSFER_CACHE_ORIGIN_MAP,
 *     useValue: {
 *         'http://internal-domain.com:8080': 'https://external-domain.com'
 *     }
 * }
 * ```
 *
 * @publicApi
 */
export const HTTP_TRANSFER_CACHE_ORIGIN_MAP = new InjectionToken(ngDevMode ? 'HTTP_TRANSFER_CACHE_ORIGIN_MAP' : '');
/**
 * Keys within cached response data structure.
 */
export const BODY = 'b';
export const HEADERS = 'h';
export const STATUS = 's';
export const STATUS_TEXT = 'st';
export const REQ_URL = 'u';
export const RESPONSE_TYPE = 'rt';
const CACHE_OPTIONS = new InjectionToken(ngDevMode ? 'HTTP_TRANSFER_STATE_CACHE_OPTIONS' : '');
/**
 * A list of allowed HTTP methods to cache.
 */
const ALLOWED_METHODS = ['GET', 'HEAD'];
export function transferCacheInterceptorFn(req, next) {
    const { isCacheActive, ...globalOptions } = inject(CACHE_OPTIONS);
    const { transferCache: requestOptions, method: requestMethod } = req;
    // In the following situations we do not want to cache the request
    if (!isCacheActive ||
        requestOptions === false ||
        // POST requests are allowed either globally or at request level
        (requestMethod === 'POST' && !globalOptions.includePostRequests && !requestOptions) ||
        (requestMethod !== 'POST' && !ALLOWED_METHODS.includes(requestMethod)) ||
        // Do not cache request that require authorization when includeRequestsWithAuthHeaders is falsey
        (!globalOptions.includeRequestsWithAuthHeaders && hasAuthHeaders(req)) ||
        globalOptions.filter?.(req) === false) {
        return next(req);
    }
    const transferState = inject(TransferState);
    const originMap = inject(HTTP_TRANSFER_CACHE_ORIGIN_MAP, {
        optional: true,
    });
    const isServer = isPlatformServer(inject(PLATFORM_ID));
    if (originMap && !isServer) {
        throw new RuntimeError(2803 /* RuntimeErrorCode.HTTP_ORIGIN_MAP_USED_IN_CLIENT */, ngDevMode &&
            'Angular detected that the `HTTP_TRANSFER_CACHE_ORIGIN_MAP` token is configured and ' +
                'present in the client side code. Please ensure that this token is only provided in the ' +
                'server code of the application.');
    }
    const requestUrl = isServer && originMap ? mapRequestOriginUrl(req.url, originMap) : req.url;
    const storeKey = makeCacheKey(req, requestUrl);
    const response = transferState.get(storeKey, null);
    let headersToInclude = globalOptions.includeHeaders;
    if (typeof requestOptions === 'object' && requestOptions.includeHeaders) {
        // Request-specific config takes precedence over the global config.
        headersToInclude = requestOptions.includeHeaders;
    }
    if (response) {
        const { [BODY]: undecodedBody, [RESPONSE_TYPE]: responseType, [HEADERS]: httpHeaders, [STATUS]: status, [STATUS_TEXT]: statusText, [REQ_URL]: url, } = response;
        // Request found in cache. Respond using it.
        let body = undecodedBody;
        switch (responseType) {
            case 'arraybuffer':
                body = new TextEncoder().encode(undecodedBody).buffer;
                break;
            case 'blob':
                body = new Blob([undecodedBody]);
                break;
        }
        // We want to warn users accessing a header provided from the cache
        // That HttpTransferCache alters the headers
        // The warning will be logged a single time by HttpHeaders instance
        let headers = new HttpHeaders(httpHeaders);
        if (typeof ngDevMode === 'undefined' || ngDevMode) {
            // Append extra logic in dev mode to produce a warning when a header
            // that was not transferred to the client is accessed in the code via `get`
            // and `has` calls.
            headers = appendMissingHeadersDetection(req.url, headers, headersToInclude ?? []);
        }
        return of(new HttpResponse({
            body,
            headers,
            status,
            statusText,
            url,
        }));
    }
    // Request not found in cache. Make the request and cache it if on the server.
    return next(req).pipe(tap((event) => {
        if (event instanceof HttpResponse && isServer) {
            transferState.set(storeKey, {
                [BODY]: event.body,
                [HEADERS]: getFilteredHeaders(event.headers, headersToInclude),
                [STATUS]: event.status,
                [STATUS_TEXT]: event.statusText,
                [REQ_URL]: requestUrl,
                [RESPONSE_TYPE]: req.responseType,
            });
        }
    }));
}
/** @returns true when the requests contains autorization related headers. */
function hasAuthHeaders(req) {
    return req.headers.has('authorization') || req.headers.has('proxy-authorization');
}
function getFilteredHeaders(headers, includeHeaders) {
    if (!includeHeaders) {
        return {};
    }
    const headersMap = {};
    for (const key of includeHeaders) {
        const values = headers.getAll(key);
        if (values !== null) {
            headersMap[key] = values;
        }
    }
    return headersMap;
}
function sortAndConcatParams(params) {
    return [...params.keys()]
        .sort()
        .map((k) => `${k}=${params.getAll(k)}`)
        .join('&');
}
function makeCacheKey(request, mappedRequestUrl) {
    // make the params encoded same as a url so it's easy to identify
    const { params, method, responseType } = request;
    const encodedParams = sortAndConcatParams(params);
    let serializedBody = request.serializeBody();
    if (serializedBody instanceof URLSearchParams) {
        serializedBody = sortAndConcatParams(serializedBody);
    }
    else if (typeof serializedBody !== 'string') {
        serializedBody = '';
    }
    const key = [method, responseType, mappedRequestUrl, serializedBody, encodedParams].join('|');
    const hash = generateHash(key);
    return makeStateKey(hash);
}
/**
 * A method that returns a hash representation of a string using a variant of DJB2 hash
 * algorithm.
 *
 * This is the same hashing logic that is used to generate component ids.
 */
function generateHash(value) {
    let hash = 0;
    for (const char of value) {
        hash = (Math.imul(31, hash) + char.charCodeAt(0)) << 0;
    }
    // Force positive number hash.
    // 2147483647 = equivalent of Integer.MAX_VALUE.
    hash += 2147483647 + 1;
    return hash.toString();
}
/**
 * Returns the DI providers needed to enable HTTP transfer cache.
 *
 * By default, when using server rendering, requests are performed twice: once on the server and
 * other one on the browser.
 *
 * When these providers are added, requests performed on the server are cached and reused during the
 * bootstrapping of the application in the browser thus avoiding duplicate requests and reducing
 * load time.
 *
 */
export function withHttpTransferCache(cacheOptions) {
    return [
        {
            provide: CACHE_OPTIONS,
            useFactory: () => {
                performanceMarkFeature('NgHttpTransferCache');
                return { isCacheActive: true, ...cacheOptions };
            },
        },
        {
            provide: HTTP_ROOT_INTERCEPTOR_FNS,
            useValue: transferCacheInterceptorFn,
            multi: true,
            deps: [TransferState, CACHE_OPTIONS],
        },
        {
            provide: APP_BOOTSTRAP_LISTENER,
            multi: true,
            useFactory: () => {
                const appRef = inject(ApplicationRef);
                const cacheState = inject(CACHE_OPTIONS);
                return () => {
                    whenStable(appRef).then(() => {
                        cacheState.isCacheActive = false;
                    });
                };
            },
        },
    ];
}
/**
 * This function will add a proxy to an HttpHeader to intercept calls to get/has
 * and log a warning if the header entry requested has been removed
 */
function appendMissingHeadersDetection(url, headers, headersToInclude) {
    const warningProduced = new Set();
    return new Proxy(headers, {
        get(target, prop) {
            const value = Reflect.get(target, prop);
            const methods = new Set(['get', 'has', 'getAll']);
            if (typeof value !== 'function' || !methods.has(prop)) {
                return value;
            }
            return (headerName) => {
                // We log when the key has been removed and a warning hasn't been produced for the header
                const key = (prop + ':' + headerName).toLowerCase(); // e.g. `get:cache-control`
                if (!headersToInclude.includes(headerName) && !warningProduced.has(key)) {
                    warningProduced.add(key);
                    const truncatedUrl = truncateMiddle(url);
                    // TODO: create Error guide for this warning
                    console.warn(formatRuntimeError(2802 /* RuntimeErrorCode.HEADERS_ALTERED_BY_TRANSFER_CACHE */, `Angular detected that the \`${headerName}\` header is accessed, but the value of the header ` +
                        `was not transferred from the server to the client by the HttpTransferCache. ` +
                        `To include the value of the \`${headerName}\` header for the \`${truncatedUrl}\` request, ` +
                        `use the \`includeHeaders\` list. The \`includeHeaders\` can be defined either ` +
                        `on a request level by adding the \`transferCache\` parameter, or on an application ` +
                        `level by adding the \`httpCacheTransfer.includeHeaders\` argument to the ` +
                        `\`provideClientHydration()\` call. `));
                }
                // invoking the original method
                return value.apply(target, [headerName]);
            };
        },
    });
}
function mapRequestOriginUrl(url, originMap) {
    const origin = new URL(url, 'resolve://').origin;
    const mappedOrigin = originMap[origin];
    if (!mappedOrigin) {
        return url;
    }
    if (typeof ngDevMode === 'undefined' || ngDevMode) {
        verifyMappedOrigin(mappedOrigin);
    }
    return url.replace(origin, mappedOrigin);
}
function verifyMappedOrigin(url) {
    if (new URL(url, 'resolve://').pathname !== '/') {
        throw new RuntimeError(2804 /* RuntimeErrorCode.HTTP_ORIGIN_MAP_CONTAINS_PATH */, 'Angular detected a URL with a path segment in the value provided for the ' +
            `\`HTTP_TRANSFER_CACHE_ORIGIN_MAP\` token: ${url}. The map should only contain origins ` +
            'without any other segments.');
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transfer_cache.js","sourceRoot":"","sources":["../../../../../../../packages/common/http/src/transfer_cache.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  APP_BOOTSTRAP_LISTENER,\n  ApplicationRef,\n  inject,\n  InjectionToken,\n  makeStateKey,\n  PLATFORM_ID,\n  Provider,\n  StateKey,\n  TransferState,\n  ɵformatRuntimeError as formatRuntimeError,\n  ɵperformanceMarkFeature as performanceMarkFeature,\n  ɵtruncateMiddle as truncateMiddle,\n  ɵwhenStable as whenStable,\n  ɵRuntimeError as RuntimeError,\n} from '@angular/core';\nimport {isPlatformServer} from '@angular/common';\nimport {Observable, of} from 'rxjs';\nimport {tap} from 'rxjs/operators';\n\nimport {RuntimeErrorCode} from './errors';\nimport {HttpHeaders} from './headers';\nimport {HTTP_ROOT_INTERCEPTOR_FNS, HttpHandlerFn} from './interceptor';\nimport {HttpRequest} from './request';\nimport {HttpEvent, HttpResponse} from './response';\nimport {HttpParams} from './params';\n\n/**\n * Options to configure how TransferCache should be used to cache requests made via HttpClient.\n *\n * @param includeHeaders Specifies which headers should be included into cached responses. No\n *     headers are included by default.\n * @param filter A function that receives a request as an argument and returns a boolean to indicate\n *     whether a request should be included into the cache.\n * @param includePostRequests Enables caching for POST requests. By default, only GET and HEAD\n *     requests are cached. This option can be enabled if POST requests are used to retrieve data\n *     (for example using GraphQL).\n * @param includeRequestsWithAuthHeaders Enables caching of requests containing either `Authorization`\n *     or `Proxy-Authorization` headers. By default, these requests are excluded from caching.\n *\n * @publicApi\n */\nexport type HttpTransferCacheOptions = {\n  includeHeaders?: string[];\n  filter?: (req: HttpRequest<unknown>) => boolean;\n  includePostRequests?: boolean;\n  includeRequestsWithAuthHeaders?: boolean;\n};\n\n/**\n * If your application uses different HTTP origins to make API calls (via `HttpClient`) on the server and\n * on the client, the `HTTP_TRANSFER_CACHE_ORIGIN_MAP` token allows you to establish a mapping\n * between those origins, so that `HttpTransferCache` feature can recognize those requests as the same\n * ones and reuse the data cached on the server during hydration on the client.\n *\n * **Important note**: the `HTTP_TRANSFER_CACHE_ORIGIN_MAP` token should *only* be provided in\n * the *server* code of your application (typically in the `app.server.config.ts` script). Angular throws an\n * error if it detects that the token is defined while running on the client.\n *\n * @usageNotes\n *\n * When the same API endpoint is accessed via `http://internal-domain.com:8080` on the server and\n * via `https://external-domain.com` on the client, you can use the following configuration:\n * ```typescript\n * // in app.server.config.ts\n * {\n *     provide: HTTP_TRANSFER_CACHE_ORIGIN_MAP,\n *     useValue: {\n *         'http://internal-domain.com:8080': 'https://external-domain.com'\n *     }\n * }\n * ```\n *\n * @publicApi\n */\nexport const HTTP_TRANSFER_CACHE_ORIGIN_MAP = new InjectionToken<Record<string, string>>(\n  ngDevMode ? 'HTTP_TRANSFER_CACHE_ORIGIN_MAP' : '',\n);\n\n/**\n * Keys within cached response data structure.\n */\n\nexport const BODY = 'b';\nexport const HEADERS = 'h';\nexport const STATUS = 's';\nexport const STATUS_TEXT = 'st';\nexport const REQ_URL = 'u';\nexport const RESPONSE_TYPE = 'rt';\n\ninterface TransferHttpResponse {\n  /** body */\n  [BODY]: any;\n  /** headers */\n  [HEADERS]: Record<string, string[]>;\n  /** status */\n  [STATUS]?: number;\n  /** statusText */\n  [STATUS_TEXT]?: string;\n  /** url */\n  [REQ_URL]?: string;\n  /** responseType */\n  [RESPONSE_TYPE]?: HttpRequest<unknown>['responseType'];\n}\n\ninterface CacheOptions extends HttpTransferCacheOptions {\n  isCacheActive: boolean;\n}\n\nconst CACHE_OPTIONS = new InjectionToken<CacheOptions>(\n  ngDevMode ? 'HTTP_TRANSFER_STATE_CACHE_OPTIONS' : '',\n);\n\n/**\n * A list of allowed HTTP methods to cache.\n */\nconst ALLOWED_METHODS = ['GET', 'HEAD'];\n\nexport function transferCacheInterceptorFn(\n  req: HttpRequest<unknown>,\n  next: HttpHandlerFn,\n): Observable<HttpEvent<unknown>> {\n  const {isCacheActive, ...globalOptions} = inject(CACHE_OPTIONS);\n  const {transferCache: requestOptions, method: requestMethod} = req;\n\n  // In the following situations we do not want to cache the request\n  if (\n    !isCacheActive ||\n    requestOptions === false ||\n    // POST requests are allowed either globally or at request level\n    (requestMethod === 'POST' && !globalOptions.includePostRequests && !requestOptions) ||\n    (requestMethod !== 'POST' && !ALLOWED_METHODS.includes(requestMethod)) ||\n    // Do not cache request that require authorization when includeRequestsWithAuthHeaders is falsey\n    (!globalOptions.includeRequestsWithAuthHeaders && hasAuthHeaders(req)) ||\n    globalOptions.filter?.(req) === false\n  ) {\n    return next(req);\n  }\n\n  const transferState = inject(TransferState);\n\n  const originMap: Record<string, string> | null = inject(HTTP_TRANSFER_CACHE_ORIGIN_MAP, {\n    optional: true,\n  });\n  const isServer = isPlatformServer(inject(PLATFORM_ID));\n  if (originMap && !isServer) {\n    throw new RuntimeError(\n      RuntimeErrorCode.HTTP_ORIGIN_MAP_USED_IN_CLIENT,\n      ngDevMode &&\n        'Angular detected that the `HTTP_TRANSFER_CACHE_ORIGIN_MAP` token is configured and ' +\n          'present in the client side code. Please ensure that this token is only provided in the ' +\n          'server code of the application.',\n    );\n  }\n\n  const requestUrl = isServer && originMap ? mapRequestOriginUrl(req.url, originMap) : req.url;\n\n  const storeKey = makeCacheKey(req, requestUrl);\n  const response = transferState.get(storeKey, null);\n\n  let headersToInclude = globalOptions.includeHeaders;\n  if (typeof requestOptions === 'object' && requestOptions.includeHeaders) {\n    // Request-specific config takes precedence over the global config.\n    headersToInclude = requestOptions.includeHeaders;\n  }\n\n  if (response) {\n    const {\n      [BODY]: undecodedBody,\n      [RESPONSE_TYPE]: responseType,\n      [HEADERS]: httpHeaders,\n      [STATUS]: status,\n      [STATUS_TEXT]: statusText,\n      [REQ_URL]: url,\n    } = response;\n    // Request found in cache. Respond using it.\n    let body: ArrayBuffer | Blob | string | undefined = undecodedBody;\n\n    switch (responseType) {\n      case 'arraybuffer':\n        body = new TextEncoder().encode(undecodedBody).buffer;\n        break;\n      case 'blob':\n        body = new Blob([undecodedBody]);\n        break;\n    }\n\n    // We want to warn users accessing a header provided from the cache\n    // That HttpTransferCache alters the headers\n    // The warning will be logged a single time by HttpHeaders instance\n    let headers = new HttpHeaders(httpHeaders);\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      // Append extra logic in dev mode to produce a warning when a header\n      // that was not transferred to the client is accessed in the code via `get`\n      // and `has` calls.\n      headers = appendMissingHeadersDetection(req.url, headers, headersToInclude ?? []);\n    }\n\n    return of(\n      new HttpResponse({\n        body,\n        headers,\n        status,\n        statusText,\n        url,\n      }),\n    );\n  }\n\n  // Request not found in cache. Make the request and cache it if on the server.\n  return next(req).pipe(\n    tap((event: HttpEvent<unknown>) => {\n      if (event instanceof HttpResponse && isServer) {\n        transferState.set<TransferHttpResponse>(storeKey, {\n          [BODY]: event.body,\n          [HEADERS]: getFilteredHeaders(event.headers, headersToInclude),\n          [STATUS]: event.status,\n          [STATUS_TEXT]: event.statusText,\n          [REQ_URL]: requestUrl,\n          [RESPONSE_TYPE]: req.responseType,\n        });\n      }\n    }),\n  );\n}\n\n/** @returns true when the requests contains autorization related headers. */\nfunction hasAuthHeaders(req: HttpRequest<unknown>): boolean {\n  return req.headers.has('authorization') || req.headers.has('proxy-authorization');\n}\n\nfunction getFilteredHeaders(\n  headers: HttpHeaders,\n  includeHeaders: string[] | undefined,\n): Record<string, string[]> {\n  if (!includeHeaders) {\n    return {};\n  }\n\n  const headersMap: Record<string, string[]> = {};\n  for (const key of includeHeaders) {\n    const values = headers.getAll(key);\n    if (values !== null) {\n      headersMap[key] = values;\n    }\n  }\n\n  return headersMap;\n}\n\nfunction sortAndConcatParams(params: HttpParams | URLSearchParams): string {\n  return [...params.keys()]\n    .sort()\n    .map((k) => `${k}=${params.getAll(k)}`)\n    .join('&');\n}\n\nfunction makeCacheKey(\n  request: HttpRequest<any>,\n  mappedRequestUrl: string,\n): StateKey<TransferHttpResponse> {\n  // make the params encoded same as a url so it's easy to identify\n  const {params, method, responseType} = request;\n  const encodedParams = sortAndConcatParams(params);\n\n  let serializedBody = request.serializeBody();\n  if (serializedBody instanceof URLSearchParams) {\n    serializedBody = sortAndConcatParams(serializedBody);\n  } else if (typeof serializedBody !== 'string') {\n    serializedBody = '';\n  }\n\n  const key = [method, responseType, mappedRequestUrl, serializedBody, encodedParams].join('|');\n  const hash = generateHash(key);\n\n  return makeStateKey(hash);\n}\n\n/**\n * A method that returns a hash representation of a string using a variant of DJB2 hash\n * algorithm.\n *\n * This is the same hashing logic that is used to generate component ids.\n */\nfunction generateHash(value: string): string {\n  let hash = 0;\n\n  for (const char of value) {\n    hash = (Math.imul(31, hash) + char.charCodeAt(0)) << 0;\n  }\n\n  // Force positive number hash.\n  // 2147483647 = equivalent of Integer.MAX_VALUE.\n  hash += 2147483647 + 1;\n\n  return hash.toString();\n}\n\n/**\n * Returns the DI providers needed to enable HTTP transfer cache.\n *\n * By default, when using server rendering, requests are performed twice: once on the server and\n * other one on the browser.\n *\n * When these providers are added, requests performed on the server are cached and reused during the\n * bootstrapping of the application in the browser thus avoiding duplicate requests and reducing\n * load time.\n *\n */\nexport function withHttpTransferCache(cacheOptions: HttpTransferCacheOptions): Provider[] {\n  return [\n    {\n      provide: CACHE_OPTIONS,\n      useFactory: (): CacheOptions => {\n        performanceMarkFeature('NgHttpTransferCache');\n        return {isCacheActive: true, ...cacheOptions};\n      },\n    },\n    {\n      provide: HTTP_ROOT_INTERCEPTOR_FNS,\n      useValue: transferCacheInterceptorFn,\n      multi: true,\n      deps: [TransferState, CACHE_OPTIONS],\n    },\n    {\n      provide: APP_BOOTSTRAP_LISTENER,\n      multi: true,\n      useFactory: () => {\n        const appRef = inject(ApplicationRef);\n        const cacheState = inject(CACHE_OPTIONS);\n\n        return () => {\n          whenStable(appRef).then(() => {\n            cacheState.isCacheActive = false;\n          });\n        };\n      },\n    },\n  ];\n}\n\n/**\n * This function will add a proxy to an HttpHeader to intercept calls to get/has\n * and log a warning if the header entry requested has been removed\n */\nfunction appendMissingHeadersDetection(\n  url: string,\n  headers: HttpHeaders,\n  headersToInclude: string[],\n): HttpHeaders {\n  const warningProduced = new Set();\n  return new Proxy<HttpHeaders>(headers, {\n    get(target: HttpHeaders, prop: keyof HttpHeaders): unknown {\n      const value = Reflect.get(target, prop);\n      const methods: Set<keyof HttpHeaders> = new Set(['get', 'has', 'getAll']);\n\n      if (typeof value !== 'function' || !methods.has(prop)) {\n        return value;\n      }\n\n      return (headerName: string) => {\n        // We log when the key has been removed and a warning hasn't been produced for the header\n        const key = (prop + ':' + headerName).toLowerCase(); // e.g. `get:cache-control`\n        if (!headersToInclude.includes(headerName) && !warningProduced.has(key)) {\n          warningProduced.add(key);\n          const truncatedUrl = truncateMiddle(url);\n\n          // TODO: create Error guide for this warning\n          console.warn(\n            formatRuntimeError(\n              RuntimeErrorCode.HEADERS_ALTERED_BY_TRANSFER_CACHE,\n              `Angular detected that the \\`${headerName}\\` header is accessed, but the value of the header ` +\n                `was not transferred from the server to the client by the HttpTransferCache. ` +\n                `To include the value of the \\`${headerName}\\` header for the \\`${truncatedUrl}\\` request, ` +\n                `use the \\`includeHeaders\\` list. The \\`includeHeaders\\` can be defined either ` +\n                `on a request level by adding the \\`transferCache\\` parameter, or on an application ` +\n                `level by adding the \\`httpCacheTransfer.includeHeaders\\` argument to the ` +\n                `\\`provideClientHydration()\\` call. `,\n            ),\n          );\n        }\n\n        // invoking the original method\n        return (value as Function).apply(target, [headerName]);\n      };\n    },\n  });\n}\n\nfunction mapRequestOriginUrl(url: string, originMap: Record<string, string>): string {\n  const origin = new URL(url, 'resolve://').origin;\n  const mappedOrigin = originMap[origin];\n  if (!mappedOrigin) {\n    return url;\n  }\n\n  if (typeof ngDevMode === 'undefined' || ngDevMode) {\n    verifyMappedOrigin(mappedOrigin);\n  }\n\n  return url.replace(origin, mappedOrigin);\n}\n\nfunction verifyMappedOrigin(url: string): void {\n  if (new URL(url, 'resolve://').pathname !== '/') {\n    throw new RuntimeError(\n      RuntimeErrorCode.HTTP_ORIGIN_MAP_CONTAINS_PATH,\n      'Angular detected a URL with a path segment in the value provided for the ' +\n        `\\`HTTP_TRANSFER_CACHE_ORIGIN_MAP\\` token: ${url}. The map should only contain origins ` +\n        'without any other segments.',\n    );\n  }\n}\n"]}