@angular/core
Version:
Angular - the core framework
171 lines • 27.2 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 { IMAGE_CONFIG } from './application/application_tokens';
import { Injectable } from './di';
import { inject } from './di/injector_compatibility';
import { formatRuntimeError } from './errors';
import { getDocument } from './render3/interfaces/document';
import { NgZone } from './zone';
import * as i0 from "./r3_symbols";
// A delay in milliseconds before the scan is run after onLoad, to avoid any
// potential race conditions with other LCP-related functions. This delay
// happens outside of the main JavaScript execution and will only effect the timing
// on when the warning becomes visible in the console.
const SCAN_DELAY = 200;
const OVERSIZED_IMAGE_TOLERANCE = 1200;
export class ImagePerformanceWarning {
constructor() {
// Map of full image URLs -> original `ngSrc` values.
this.window = null;
this.observer = null;
this.options = inject(IMAGE_CONFIG);
this.ngZone = inject(NgZone);
}
start() {
if (typeof PerformanceObserver === 'undefined' ||
(this.options?.disableImageSizeWarning && this.options?.disableImageLazyLoadWarning)) {
return;
}
this.observer = this.initPerformanceObserver();
const doc = getDocument();
const win = doc.defaultView;
if (typeof win !== 'undefined') {
this.window = win;
// Wait to avoid race conditions where LCP image triggers
// load event before it's recorded by the performance observer
const waitToScan = () => {
setTimeout(this.scanImages.bind(this), SCAN_DELAY);
};
// Angular doesn't have to run change detection whenever any asynchronous tasks are invoked in
// the scope of this functionality.
this.ngZone.runOutsideAngular(() => {
// Consider the case when the application is created and destroyed multiple times.
// Typically, applications are created instantly once the page is loaded, and the
// `window.load` listener is always triggered. However, the `window.load` event will never
// be fired if the page is loaded, and the application is created later. Checking for
// `readyState` is the easiest way to determine whether the page has been loaded or not.
if (doc.readyState === 'complete') {
waitToScan();
}
else {
this.window?.addEventListener('load', waitToScan, { once: true });
}
});
}
}
ngOnDestroy() {
this.observer?.disconnect();
}
initPerformanceObserver() {
if (typeof PerformanceObserver === 'undefined') {
return null;
}
const observer = new PerformanceObserver((entryList) => {
const entries = entryList.getEntries();
if (entries.length === 0)
return;
// We use the latest entry produced by the `PerformanceObserver` as the best
// signal on which element is actually an LCP one. As an example, the first image to load on
// a page, by virtue of being the only thing on the page so far, is often a LCP candidate
// and gets reported by PerformanceObserver, but isn't necessarily the LCP element.
const lcpElement = entries[entries.length - 1];
// Cast to `any` due to missing `element` on the `LargestContentfulPaint` type of entry.
// See https://developer.mozilla.org/en-US/docs/Web/API/LargestContentfulPaint
const imgSrc = lcpElement.element?.src ?? '';
// Exclude `data:` and `blob:` URLs, since they are fetched resources.
if (imgSrc.startsWith('data:') || imgSrc.startsWith('blob:'))
return;
this.lcpImageUrl = imgSrc;
});
observer.observe({ type: 'largest-contentful-paint', buffered: true });
return observer;
}
scanImages() {
const images = getDocument().querySelectorAll('img');
let lcpElementFound, lcpElementLoadedCorrectly = false;
images.forEach(image => {
if (!this.options?.disableImageSizeWarning) {
for (const image of images) {
// Image elements using the NgOptimizedImage directive are excluded,
// as that directive has its own version of this check.
if (!image.getAttribute('ng-img') && this.isOversized(image)) {
logOversizedImageWarning(image.src);
}
}
}
if (!this.options?.disableImageLazyLoadWarning && this.lcpImageUrl) {
if (image.src === this.lcpImageUrl) {
lcpElementFound = true;
if (image.loading !== 'lazy' || image.getAttribute('ng-img')) {
// This variable is set to true and never goes back to false to account
// for the case where multiple images have the same src url, and some
// have lazy loading while others don't.
// Also ignore NgOptimizedImage because there's a different warning for that.
lcpElementLoadedCorrectly = true;
}
}
}
});
if (lcpElementFound && !lcpElementLoadedCorrectly && this.lcpImageUrl &&
!this.options?.disableImageLazyLoadWarning) {
logLazyLCPWarning(this.lcpImageUrl);
}
}
isOversized(image) {
if (!this.window) {
return false;
}
const computedStyle = this.window.getComputedStyle(image);
let renderedWidth = parseFloat(computedStyle.getPropertyValue('width'));
let renderedHeight = parseFloat(computedStyle.getPropertyValue('height'));
const boxSizing = computedStyle.getPropertyValue('box-sizing');
const objectFit = computedStyle.getPropertyValue('object-fit');
if (objectFit === `cover`) {
// Object fit cover may indicate a use case such as a sprite sheet where
// this warning does not apply.
return false;
}
if (boxSizing === 'border-box') {
const paddingTop = computedStyle.getPropertyValue('padding-top');
const paddingRight = computedStyle.getPropertyValue('padding-right');
const paddingBottom = computedStyle.getPropertyValue('padding-bottom');
const paddingLeft = computedStyle.getPropertyValue('padding-left');
renderedWidth -= parseFloat(paddingRight) + parseFloat(paddingLeft);
renderedHeight -= parseFloat(paddingTop) + parseFloat(paddingBottom);
}
const intrinsicWidth = image.naturalWidth;
const intrinsicHeight = image.naturalHeight;
const recommendedWidth = this.window.devicePixelRatio * renderedWidth;
const recommendedHeight = this.window.devicePixelRatio * renderedHeight;
const oversizedWidth = (intrinsicWidth - recommendedWidth) >= OVERSIZED_IMAGE_TOLERANCE;
const oversizedHeight = (intrinsicHeight - recommendedHeight) >= OVERSIZED_IMAGE_TOLERANCE;
return oversizedWidth || oversizedHeight;
}
static { this.ɵfac = function ImagePerformanceWarning_Factory(t) { return new (t || ImagePerformanceWarning)(); }; }
static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ImagePerformanceWarning, factory: ImagePerformanceWarning.ɵfac, providedIn: 'root' }); }
}
(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.setClassMetadata(ImagePerformanceWarning, [{
type: Injectable,
args: [{ providedIn: 'root' }]
}], null, null); })();
function logLazyLCPWarning(src) {
console.warn(formatRuntimeError(-913 /* RuntimeErrorCode.IMAGE_PERFORMANCE_WARNING */, `An image with src ${src} is the Largest Contentful Paint (LCP) element ` +
`but was given a "loading" value of "lazy", which can negatively impact ` +
`application loading performance. This warning can be addressed by ` +
`changing the loading value of the LCP image to "eager", or by using the ` +
`NgOptimizedImage directive's prioritization utilities. For more ` +
`information about addressing or disabling this warning, see ` +
`https://angular.io/errors/NG0913`));
}
function logOversizedImageWarning(src) {
console.warn(formatRuntimeError(-913 /* RuntimeErrorCode.IMAGE_PERFORMANCE_WARNING */, `An image with src ${src} has intrinsic file dimensions much larger than its ` +
`rendered size. This can negatively impact application loading performance. ` +
`For more information about addressing or disabling this warning, see ` +
`https://angular.io/errors/NG0913`));
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image_performance_warning.js","sourceRoot":"","sources":["../../../../../../packages/core/src/image_performance_warning.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 {IMAGE_CONFIG, ImageConfig} from './application/application_tokens';\nimport {Injectable} from './di';\nimport {inject} from './di/injector_compatibility';\nimport {formatRuntimeError, RuntimeErrorCode} from './errors';\nimport {OnDestroy} from './interface/lifecycle_hooks';\nimport {getDocument} from './render3/interfaces/document';\nimport {NgZone} from './zone';\n\n// A delay in milliseconds before the scan is run after onLoad, to avoid any\n// potential race conditions with other LCP-related functions. This delay\n// happens outside of the main JavaScript execution and will only effect the timing\n// on when the warning becomes visible in the console.\nconst SCAN_DELAY = 200;\n\nconst OVERSIZED_IMAGE_TOLERANCE = 1200;\n\n@Injectable({providedIn: 'root'})\nexport class ImagePerformanceWarning implements OnDestroy {\n  // Map of full image URLs -> original `ngSrc` values.\n  private window: Window|null = null;\n  private observer: PerformanceObserver|null = null;\n  private options: ImageConfig = inject(IMAGE_CONFIG);\n  private ngZone = inject(NgZone);\n  private lcpImageUrl?: string;\n\n  public start() {\n    if (typeof PerformanceObserver === 'undefined' ||\n        (this.options?.disableImageSizeWarning && this.options?.disableImageLazyLoadWarning)) {\n      return;\n    }\n    this.observer = this.initPerformanceObserver();\n    const doc = getDocument();\n    const win = doc.defaultView;\n    if (typeof win !== 'undefined') {\n      this.window = win;\n      // Wait to avoid race conditions where LCP image triggers\n      // load event before it's recorded by the performance observer\n      const waitToScan = () => {\n        setTimeout(this.scanImages.bind(this), SCAN_DELAY);\n      };\n      // Angular doesn't have to run change detection whenever any asynchronous tasks are invoked in\n      // the scope of this functionality.\n      this.ngZone.runOutsideAngular(() => {\n        // Consider the case when the application is created and destroyed multiple times.\n        // Typically, applications are created instantly once the page is loaded, and the\n        // `window.load` listener is always triggered. However, the `window.load` event will never\n        // be fired if the page is loaded, and the application is created later. Checking for\n        // `readyState` is the easiest way to determine whether the page has been loaded or not.\n        if (doc.readyState === 'complete') {\n          waitToScan();\n        } else {\n          this.window?.addEventListener('load', waitToScan, {once: true});\n        }\n      });\n    }\n  }\n\n  ngOnDestroy() {\n    this.observer?.disconnect();\n  }\n\n  private initPerformanceObserver(): PerformanceObserver|null {\n    if (typeof PerformanceObserver === 'undefined') {\n      return null;\n    }\n    const observer = new PerformanceObserver((entryList) => {\n      const entries = entryList.getEntries();\n      if (entries.length === 0) return;\n      // We use the latest entry produced by the `PerformanceObserver` as the best\n      // signal on which element is actually an LCP one. As an example, the first image to load on\n      // a page, by virtue of being the only thing on the page so far, is often a LCP candidate\n      // and gets reported by PerformanceObserver, but isn't necessarily the LCP element.\n      const lcpElement = entries[entries.length - 1];\n\n      // Cast to `any` due to missing `element` on the `LargestContentfulPaint` type of entry.\n      // See https://developer.mozilla.org/en-US/docs/Web/API/LargestContentfulPaint\n      const imgSrc = (lcpElement as any).element?.src ?? '';\n\n      // Exclude `data:` and `blob:` URLs, since they are fetched resources.\n      if (imgSrc.startsWith('data:') || imgSrc.startsWith('blob:')) return;\n      this.lcpImageUrl = imgSrc;\n    });\n    observer.observe({type: 'largest-contentful-paint', buffered: true});\n    return observer;\n  }\n\n  private scanImages(): void {\n    const images = getDocument().querySelectorAll('img');\n    let lcpElementFound, lcpElementLoadedCorrectly = false;\n    images.forEach(image => {\n      if (!this.options?.disableImageSizeWarning) {\n        for (const image of images) {\n          // Image elements using the NgOptimizedImage directive are excluded,\n          // as that directive has its own version of this check.\n          if (!image.getAttribute('ng-img') && this.isOversized(image)) {\n            logOversizedImageWarning(image.src);\n          }\n        }\n      }\n      if (!this.options?.disableImageLazyLoadWarning && this.lcpImageUrl) {\n        if (image.src === this.lcpImageUrl) {\n          lcpElementFound = true;\n          if (image.loading !== 'lazy' || image.getAttribute('ng-img')) {\n            // This variable is set to true and never goes back to false to account\n            // for the case where multiple images have the same src url, and some\n            // have lazy loading while others don't.\n            // Also ignore NgOptimizedImage because there's a different warning for that.\n            lcpElementLoadedCorrectly = true;\n          }\n        }\n      }\n    });\n    if (lcpElementFound && !lcpElementLoadedCorrectly && this.lcpImageUrl &&\n        !this.options?.disableImageLazyLoadWarning) {\n      logLazyLCPWarning(this.lcpImageUrl);\n    }\n  }\n\n  private isOversized(image: HTMLImageElement): boolean {\n    if (!this.window) {\n      return false;\n    }\n    const computedStyle = this.window.getComputedStyle(image);\n    let renderedWidth = parseFloat(computedStyle.getPropertyValue('width'));\n    let renderedHeight = parseFloat(computedStyle.getPropertyValue('height'));\n    const boxSizing = computedStyle.getPropertyValue('box-sizing');\n    const objectFit = computedStyle.getPropertyValue('object-fit');\n\n    if (objectFit === `cover`) {\n      // Object fit cover may indicate a use case such as a sprite sheet where\n      // this warning does not apply.\n      return false;\n    }\n\n    if (boxSizing === 'border-box') {\n      const paddingTop = computedStyle.getPropertyValue('padding-top');\n      const paddingRight = computedStyle.getPropertyValue('padding-right');\n      const paddingBottom = computedStyle.getPropertyValue('padding-bottom');\n      const paddingLeft = computedStyle.getPropertyValue('padding-left');\n      renderedWidth -= parseFloat(paddingRight) + parseFloat(paddingLeft);\n      renderedHeight -= parseFloat(paddingTop) + parseFloat(paddingBottom);\n    }\n\n    const intrinsicWidth = image.naturalWidth;\n    const intrinsicHeight = image.naturalHeight;\n\n    const recommendedWidth = this.window.devicePixelRatio * renderedWidth;\n    const recommendedHeight = this.window.devicePixelRatio * renderedHeight;\n    const oversizedWidth = (intrinsicWidth - recommendedWidth) >= OVERSIZED_IMAGE_TOLERANCE;\n    const oversizedHeight = (intrinsicHeight - recommendedHeight) >= OVERSIZED_IMAGE_TOLERANCE;\n    return oversizedWidth || oversizedHeight;\n  }\n}\n\nfunction logLazyLCPWarning(src: string) {\n  console.warn(formatRuntimeError(\n      RuntimeErrorCode.IMAGE_PERFORMANCE_WARNING,\n      `An image with src ${src} is the Largest Contentful Paint (LCP) element ` +\n          `but was given a \"loading\" value of \"lazy\", which can negatively impact ` +\n          `application loading performance. This warning can be addressed by ` +\n          `changing the loading value of the LCP image to \"eager\", or by using the ` +\n          `NgOptimizedImage directive's prioritization utilities. For more ` +\n          `information about addressing or disabling this warning, see ` +\n          `https://angular.io/errors/NG0913`));\n}\n\nfunction logOversizedImageWarning(src: string) {\n  console.warn(formatRuntimeError(\n      RuntimeErrorCode.IMAGE_PERFORMANCE_WARNING,\n      `An image with src ${src} has intrinsic file dimensions much larger than its ` +\n          `rendered size. This can negatively impact application loading performance. ` +\n          `For more information about addressing or disabling this warning, see ` +\n          `https://angular.io/errors/NG0913`));\n}\n"]}