@angular/common
Version:
Angular - commonly needed directives and services
138 lines • 17.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, Injectable, InjectionToken, ɵformatRuntimeError as formatRuntimeError, ɵRuntimeError as RuntimeError } from '@angular/core';
import { DOCUMENT } from '../../dom_tokens';
import { assertDevMode } from './asserts';
import { imgDirectiveDetails } from './error_helper';
import { extractHostname, getUrl } from './url';
import * as i0 from "@angular/core";
// Set of origins that are always excluded from the preconnect checks.
const INTERNAL_PRECONNECT_CHECK_BLOCKLIST = new Set(['localhost', '127.0.0.1', '0.0.0.0']);
/**
* Multi-provider injection token to configure which origins should be excluded
* from the preconnect checks. It can either be a single string or an array of strings
* to represent a group of origins, for example:
*
* ```typescript
* {provide: PRECONNECT_CHECK_BLOCKLIST, multi: true, useValue: 'https://your-domain.com'}
* ```
*
* or:
*
* ```typescript
* {provide: PRECONNECT_CHECK_BLOCKLIST, multi: true,
* useValue: ['https://your-domain-1.com', 'https://your-domain-2.com']}
* ```
*
* @publicApi
* @developerPreview
*/
export const PRECONNECT_CHECK_BLOCKLIST = new InjectionToken('PRECONNECT_CHECK_BLOCKLIST');
/**
* Contains the logic to detect whether an image, marked with the "priority" attribute
* has a corresponding `<link rel="preconnect">` tag in the `document.head`.
*
* Note: this is a dev-mode only class, which should not appear in prod bundles,
* thus there is no `ngDevMode` use in the code.
*/
export class PreconnectLinkChecker {
constructor() {
this.document = inject(DOCUMENT);
/**
* Set of <link rel="preconnect"> tags found on this page.
* The `null` value indicates that there was no DOM query operation performed.
*/
this.preconnectLinks = null;
/*
* Keep track of all already seen origin URLs to avoid repeating the same check.
*/
this.alreadySeen = new Set();
this.window = null;
this.blocklist = new Set(INTERNAL_PRECONNECT_CHECK_BLOCKLIST);
assertDevMode('preconnect link checker');
const win = this.document.defaultView;
if (typeof win !== 'undefined') {
this.window = win;
}
const blocklist = inject(PRECONNECT_CHECK_BLOCKLIST, { optional: true });
if (blocklist) {
this.populateBlocklist(blocklist);
}
}
populateBlocklist(origins) {
if (Array.isArray(origins)) {
deepForEach(origins, origin => {
this.blocklist.add(extractHostname(origin));
});
}
else {
throw new RuntimeError(2957 /* RuntimeErrorCode.INVALID_PRECONNECT_CHECK_BLOCKLIST */, `The blocklist for the preconnect check was not provided as an array. ` +
`Check that the \`PRECONNECT_CHECK_BLOCKLIST\` token is configured as a \`multi: true\` provider.`);
}
}
/**
* Checks that a preconnect resource hint exists in the head fo rthe
* given src.
*
* @param rewrittenSrc src formatted with loader
* @param originalNgSrc ngSrc value
*/
assertPreconnect(rewrittenSrc, originalNgSrc) {
if (!this.window)
return;
const imgUrl = getUrl(rewrittenSrc, this.window);
if (this.blocklist.has(imgUrl.hostname) || this.alreadySeen.has(imgUrl.origin))
return;
// Register this origin as seen, so we don't check it again later.
this.alreadySeen.add(imgUrl.origin);
if (!this.preconnectLinks) {
// Note: we query for preconnect links only *once* and cache the results
// for the entire lifespan of an application, since it's unlikely that the
// list would change frequently. This allows to make sure there are no
// performance implications of making extra DOM lookups for each image.
this.preconnectLinks = this.queryPreconnectLinks();
}
if (!this.preconnectLinks.has(imgUrl.origin)) {
console.warn(formatRuntimeError(2956 /* RuntimeErrorCode.PRIORITY_IMG_MISSING_PRECONNECT_TAG */, `${imgDirectiveDetails(originalNgSrc)} there is no preconnect tag present for this ` +
`image. Preconnecting to the origin(s) that serve priority images ensures that these ` +
`images are delivered as soon as possible. To fix this, please add the following ` +
`element into the <head> of the document:\n` +
` <link rel="preconnect" href="${imgUrl.origin}">`));
}
}
queryPreconnectLinks() {
const preconnectUrls = new Set();
const selector = 'link[rel=preconnect]';
const links = Array.from(this.document.querySelectorAll(selector));
for (let link of links) {
const url = getUrl(link.href, this.window);
preconnectUrls.add(url.origin);
}
return preconnectUrls;
}
ngOnDestroy() {
this.preconnectLinks?.clear();
this.alreadySeen.clear();
}
}
PreconnectLinkChecker.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.5", ngImport: i0, type: PreconnectLinkChecker, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
PreconnectLinkChecker.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.5", ngImport: i0, type: PreconnectLinkChecker, providedIn: 'root' });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.5", ngImport: i0, type: PreconnectLinkChecker, decorators: [{
type: Injectable,
args: [{ providedIn: 'root' }]
}], ctorParameters: function () { return []; } });
/**
* Invokes a callback for each element in the array. Also invokes a callback
* recursively for each nested array.
*/
function deepForEach(input, fn) {
for (let value of input) {
Array.isArray(value) ? deepForEach(value, fn) : fn(value);
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preconnect_link_checker.js","sourceRoot":"","sources":["../../../../../../../../packages/common/src/directives/ng_optimized_image/preconnect_link_checker.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.io/license\n */\n\nimport {inject, Injectable, InjectionToken, ɵformatRuntimeError as formatRuntimeError, ɵRuntimeError as RuntimeError} from '@angular/core';\n\nimport {DOCUMENT} from '../../dom_tokens';\nimport {RuntimeErrorCode} from '../../errors';\n\nimport {assertDevMode} from './asserts';\nimport {imgDirectiveDetails} from './error_helper';\nimport {extractHostname, getUrl} from './url';\n\n// Set of origins that are always excluded from the preconnect checks.\nconst INTERNAL_PRECONNECT_CHECK_BLOCKLIST = new Set(['localhost', '127.0.0.1', '0.0.0.0']);\n\n/**\n * Multi-provider injection token to configure which origins should be excluded\n * from the preconnect checks. It can either be a single string or an array of strings\n * to represent a group of origins, for example:\n *\n * ```typescript\n *  {provide: PRECONNECT_CHECK_BLOCKLIST, multi: true, useValue: 'https://your-domain.com'}\n * ```\n *\n * or:\n *\n * ```typescript\n *  {provide: PRECONNECT_CHECK_BLOCKLIST, multi: true,\n *   useValue: ['https://your-domain-1.com', 'https://your-domain-2.com']}\n * ```\n *\n * @publicApi\n * @developerPreview\n */\nexport const PRECONNECT_CHECK_BLOCKLIST =\n    new InjectionToken<Array<string|string[]>>('PRECONNECT_CHECK_BLOCKLIST');\n\n/**\n * Contains the logic to detect whether an image, marked with the \"priority\" attribute\n * has a corresponding `<link rel=\"preconnect\">` tag in the `document.head`.\n *\n * Note: this is a dev-mode only class, which should not appear in prod bundles,\n * thus there is no `ngDevMode` use in the code.\n */\n@Injectable({providedIn: 'root'})\nexport class PreconnectLinkChecker {\n  private document = inject(DOCUMENT);\n\n  /**\n   * Set of <link rel=\"preconnect\"> tags found on this page.\n   * The `null` value indicates that there was no DOM query operation performed.\n   */\n  private preconnectLinks: Set<string>|null = null;\n\n  /*\n   * Keep track of all already seen origin URLs to avoid repeating the same check.\n   */\n  private alreadySeen = new Set<string>();\n\n  private window: Window|null = null;\n\n  private blocklist = new Set<string>(INTERNAL_PRECONNECT_CHECK_BLOCKLIST);\n\n  constructor() {\n    assertDevMode('preconnect link checker');\n    const win = this.document.defaultView;\n    if (typeof win !== 'undefined') {\n      this.window = win;\n    }\n    const blocklist = inject(PRECONNECT_CHECK_BLOCKLIST, {optional: true});\n    if (blocklist) {\n      this.populateBlocklist(blocklist);\n    }\n  }\n\n  private populateBlocklist(origins: Array<string|string[]>) {\n    if (Array.isArray(origins)) {\n      deepForEach(origins, origin => {\n        this.blocklist.add(extractHostname(origin));\n      });\n    } else {\n      throw new RuntimeError(\n          RuntimeErrorCode.INVALID_PRECONNECT_CHECK_BLOCKLIST,\n          `The blocklist for the preconnect check was not provided as an array. ` +\n              `Check that the \\`PRECONNECT_CHECK_BLOCKLIST\\` token is configured as a \\`multi: true\\` provider.`);\n    }\n  }\n\n  /**\n   * Checks that a preconnect resource hint exists in the head fo rthe\n   * given src.\n   *\n   * @param rewrittenSrc src formatted with loader\n   * @param originalNgSrc ngSrc value\n   */\n  assertPreconnect(rewrittenSrc: string, originalNgSrc: string): void {\n    if (!this.window) return;\n\n    const imgUrl = getUrl(rewrittenSrc, this.window);\n    if (this.blocklist.has(imgUrl.hostname) || this.alreadySeen.has(imgUrl.origin)) return;\n\n    // Register this origin as seen, so we don't check it again later.\n    this.alreadySeen.add(imgUrl.origin);\n\n    if (!this.preconnectLinks) {\n      // Note: we query for preconnect links only *once* and cache the results\n      // for the entire lifespan of an application, since it's unlikely that the\n      // list would change frequently. This allows to make sure there are no\n      // performance implications of making extra DOM lookups for each image.\n      this.preconnectLinks = this.queryPreconnectLinks();\n    }\n\n    if (!this.preconnectLinks.has(imgUrl.origin)) {\n      console.warn(formatRuntimeError(\n          RuntimeErrorCode.PRIORITY_IMG_MISSING_PRECONNECT_TAG,\n          `${imgDirectiveDetails(originalNgSrc)} there is no preconnect tag present for this ` +\n              `image. Preconnecting to the origin(s) that serve priority images ensures that these ` +\n              `images are delivered as soon as possible. To fix this, please add the following ` +\n              `element into the <head> of the document:\\n` +\n              `  <link rel=\"preconnect\" href=\"${imgUrl.origin}\">`));\n    }\n  }\n\n  private queryPreconnectLinks(): Set<string> {\n    const preconnectUrls = new Set<string>();\n    const selector = 'link[rel=preconnect]';\n    const links: HTMLLinkElement[] = Array.from(this.document.querySelectorAll(selector));\n    for (let link of links) {\n      const url = getUrl(link.href, this.window!);\n      preconnectUrls.add(url.origin);\n    }\n    return preconnectUrls;\n  }\n\n  ngOnDestroy() {\n    this.preconnectLinks?.clear();\n    this.alreadySeen.clear();\n  }\n}\n\n/**\n * Invokes a callback for each element in the array. Also invokes a callback\n * recursively for each nested array.\n */\nfunction deepForEach<T>(input: (T|any[])[], fn: (value: T) => void): void {\n  for (let value of input) {\n    Array.isArray(value) ? deepForEach(value, fn) : fn(value);\n  }\n}\n"]}