Changeset 56037 for trunk/src/wp-includes/deprecated.php

Timestamp:

06/26/2023 04:15:12 PM (23 months ago)

Author:

flixos90

Message:

Media: Automatically add fetchpriority="high" to hero image to improve load time performance.

This changeset adds support for the fetchpriority attribute, which is typically added to a single image in each HTML response with a value of "high". This enhances load time performance (also Largest Contentful Paint, or LCP) by telling the browser to prioritize this image for downloading even before the layout of the page has been computed. In lab tests, this has shown to improve LCP performance by ~10% on average.

Specifically, fetchpriority="high" is added to the first image that satisfies all of the following conditions:

• The image is not lazy-loaded, i.e. does not have loading="lazy".
• The image does not already have a (conflicting) fetchpriority attribute.
• The size of of the image (i.e. width * height) is greater than 50,000 squarepixels.

While these heuristics are based on several field analyses, there will always be room for optimization. Sites can customize the squarepixel threshold using a new filter wp_min_priority_img_pixels which should return an integer for the value.

Since the logic for adding fetchpriority="high" is heavily intertwined with the logic for adding loading="lazy", yet the features should work decoupled from each other, the majority of code changes in this changeset is refactoring of the existing lazy-loading logic to be reusable. For this purpose, a new function wp_get_loading_optimization_attributes() has been introduced which returns an associative array of performance-relevant attributes for a given HTML element. This function replaces wp_get_loading_attr_default(), which has been deprecated. As another result of that change, a new function wp_img_tag_add_loading_optimization_attrs() replaces the more specific wp_img_tag_add_loading_attr(), which has been deprecated as well.

See ​https://make.wordpress.org/core/2023/05/02/proposal-for-enhancing-lcp-image-performance-with-fetchpriority/ for the original proposal and additional context.

Props thekt12, joemcgill, spacedmonkey, mukesh27, costdev, 10upsimon.
Fixes #58235.

File:

• trunk/src/wp-includes/deprecated.php (modified) (1 diff)

trunk/src/wp-includes/deprecated.php

@@ -4659 +4659 @@
     wp_lazyload_comment_meta( $comment_ids );
 }
+
+/**
+ * Gets the default value to use for a `loading` attribute on an element.
+ *
+ * This function should only be called for a tag and context if lazy-loading is generally enabled.
+ *
+ * The function usually returns 'lazy', but uses certain heuristics to guess whether the current element is likely to
+ * appear above the fold, in which case it returns a boolean `false`, which will lead to the `loading` attribute being
+ * omitted on the element. The purpose of this refinement is to avoid lazy-loading elements that are within the initial
+ * viewport, which can have a negative performance impact.
+ *
+ * Under the hood, the function uses {@see wp_increase_content_media_count()} every time it is called for an element
+ * within the main content. If the element is the very first content element, the `loading` attribute will be omitted.
+ * This default threshold of 3 content elements to omit the `loading` attribute for can be customized using the
+ * {@see 'wp_omit_loading_attr_threshold'} filter.
+ *
+ * @since 5.9.0
+ * @deprecated 6.3.0 Use wp_get_loading_optimization_attributes() instead.
+ * @see wp_get_loading_optimization_attributes()
+ *
+ * @global WP_Query $wp_query WordPress Query object.
+ *
+ * @param string $context Context for the element for which the `loading` attribute value is requested.
+ * @return string|bool The default `loading` attribute value. Either 'lazy', 'eager', or a boolean `false`, to indicate
+ *                     that the `loading` attribute should be skipped.
+ */
+function wp_get_loading_attr_default( $context ) {
+    _deprecated_function( __FUNCTION__, '6.3.0', 'wp_get_loading_optimization_attributes' );
+    global $wp_query;
+
+    // Skip lazy-loading for the overall block template, as it is handled more granularly.
+    if ( 'template' === $context ) {
+        return false;
+    }
+
+    /*
+     * Do not lazy-load images in the header block template part, as they are likely above the fold.
+     * For classic themes, this is handled in the condition below using the 'get_header' action.
+     */
+    $header_area = WP_TEMPLATE_PART_AREA_HEADER;
+    if ( "template_part_{$header_area}" === $context ) {
+        return false;
+    }
+
+    // Special handling for programmatically created image tags.
+    if ( 'the_post_thumbnail' === $context || 'wp_get_attachment_image' === $context ) {
+        /*
+         * Skip programmatically created images within post content as they need to be handled together with the other
+         * images within the post content.
+         * Without this clause, they would already be counted below which skews the number and can result in the first
+         * post content image being lazy-loaded only because there are images elsewhere in the post content.
+         */
+        if ( doing_filter( 'the_content' ) ) {
+            return false;
+        }
+
+        // Conditionally skip lazy-loading on images before the loop.
+        if (
+            // Only apply for main query but before the loop.
+            $wp_query->before_loop && $wp_query->is_main_query()
+            /*
+             * Any image before the loop, but after the header has started should not be lazy-loaded,
+             * except when the footer has already started which can happen when the current template
+             * does not include any loop.
+             */
+            && did_action( 'get_header' ) && ! did_action( 'get_footer' )
+        ) {
+            return false;
+        }
+    }
+
+    /*
+     * The first elements in 'the_content' or 'the_post_thumbnail' should not be lazy-loaded,
+     * as they are likely above the fold.
+     */
+    if ( 'the_content' === $context || 'the_post_thumbnail' === $context ) {
+        // Only elements within the main query loop have special handling.
+        if ( is_admin() || ! in_the_loop() || ! is_main_query() ) {
+            return 'lazy';
+        }
+
+        // Increase the counter since this is a main query content element.
+        $content_media_count = wp_increase_content_media_count();
+
+        // If the count so far is below the threshold, return `false` so that the `loading` attribute is omitted.
+        if ( $content_media_count <= wp_omit_loading_attr_threshold() ) {
+            return false;
+        }
+
+        // For elements after the threshold, lazy-load them as usual.
+        return 'lazy';
+    }
+
+    // Lazy-load by default for any unknown context.
+    return 'lazy';
+}
+
+/**
+ * Adds `loading` attribute to an `img` HTML tag.
+ *
+ * @since 5.5.0
+ * @deprecated 6.3.0 Use wp_img_tag_add_loading_optimization_attrs() instead.
+ * @see wp_img_tag_add_loading_optimization_attrs()
+ *
+ * @param string $image   The HTML `img` tag where the attribute should be added.
+ * @param string $context Additional context to pass to the filters.
+ * @return string Converted `img` tag with `loading` attribute added.
+ */
+function wp_img_tag_add_loading_attr( $image, $context ) {
+    _deprecated_function( __FUNCTION__, '6.3.0', 'wp_img_tag_add_loading_optimization_attrs' );
+    /*
+     * Get loading attribute value to use. This must occur before the conditional check below so that even images that
+     * are ineligible for being lazy-loaded are considered.
+     */
+    $value = wp_get_loading_attr_default( $context );
+
+    // Images should have source and dimension attributes for the `loading` attribute to be added.
+    if ( ! str_contains( $image, ' src="' ) || ! str_contains( $image, ' width="' ) || ! str_contains( $image, ' height="' ) ) {
+        return $image;
+    }
+
+    /**
+     * Filters the `loading` attribute value to add to an image. Default `lazy`.
+     *
+     * Returning `false` or an empty string will not add the attribute.
+     * Returning `true` will add the default value.
+     *
+     * @since 5.5.0
+     *
+     * @param string|bool $value   The `loading` attribute value. Returning a falsey value will result in
+     *                             the attribute being omitted for the image.
+     * @param string      $image   The HTML `img` tag to be filtered.
+     * @param string      $context Additional context about how the function was called or where the img tag is.
+     */
+    $value = apply_filters( 'wp_img_tag_add_loading_attr', $value, $image, $context );
+
+    if ( $value ) {
+        if ( ! in_array( $value, array( 'lazy', 'eager' ), true ) ) {
+            $value = 'lazy';
+        }
+
+        return str_replace( '<img', '<img loading="' . esc_attr( $value ) . '"', $image );
+    }
+
+    return $image;
+}