Changeset 3715895 for optimazz/trunk/includes/Modules/Fonts/FontsModule.php

Timestamp:

09/27/2026 05:57:08 PM (4 weeks ago)

Author:

shiponkarmakar

Message:

Release v1.0.23

File:

• optimazz/trunk/includes/Modules/Fonts/FontsModule.php (modified) (3 diffs)

optimazz/trunk/includes/Modules/Fonts/FontsModule.php

@@ -16 +16 @@
 
 use Optimazz\Core\AbstractModule;
+use Optimazz\Core\Paths;
 
 defined( 'ABSPATH' ) || exit;
@@ -64 +65 @@
 
                 $uses_google = false !== stripos( $html, 'fonts.googleapis.com' );
+
+                // Merge every Google Fonts stylesheet into ONE request and drop the font
+                // weights the page never uses (page builders like Elementor request every
+                // weight 100–900 plus italics for each family — often 150KB+ of font CSS
+                // and a render-blocking request per family).
+                if ( $uses_google && $this->option( 'combine_google', true ) ) {
+                        $html = $this->optimize_google_fonts( $html, $display );
+                }
 
                 // Force the chosen font-display on Google Fonts stylesheet URLs. We
@@ -130 +139 @@
         }
 
+        /* --------------------------------------------------------------------- *
+         *  Google Fonts: combine + trim unused weights
+         * --------------------------------------------------------------------- */
+
+        /**
+         * Replace all Google Fonts stylesheet <link>s with a single CSS2 API request
+         * containing only the families/weights actually needed. Anything we can't
+         * parse with certainty (e.g. `text=` subsetting) is left untouched, and the
+         * whole step fails open — the page is never left without its fonts.
+         *
+         * @param string $html    Page HTML.
+         * @param string $display font-display value to request ('' keeps original).
+         * @return string
+         */
+        private function optimize_google_fonts( $html, $display ) {
+                if ( ! preg_match_all( '#<link\b[^>]*>#i', $html, $all ) ) {
+                        return $html;
+                }
+
+                $links    = array(); // Tags we will merge (in document order).
+                $families = array(); // name => ['normal'=>[w=>1], 'italic'=>[w=>1], 'raw'=>string|null]
+                $orig_display = '';
+
+                foreach ( $all[0] as $tag ) {
+                        if ( ! preg_match( '#\brel\s*=\s*["\']?stylesheet\b#i', $tag ) ) {
+                                continue;
+                        }
+                        if ( ! preg_match( '#\bhref\s*=\s*(["\'])((?:https?:)?//fonts\.googleapis\.com/(css2?)\?[^"\']+)\1#i', $tag, $m ) ) {
+                                continue;
+                        }
+                        if ( preg_match( '#\bmedia\s*=\s*["\'](?!all\b|screen\b)[^"\']+#i', $tag ) ) {
+                                continue; // print-only etc. — leave alone.
+                        }
+                        $query  = (string) wp_parse_url( html_entity_decode( $m[2], ENT_QUOTES ), PHP_URL_QUERY ); // decode first: "&#038;" contains a "#" that would truncate the query.
+                        $parsed = 'css2' === strtolower( $m[3] ) ? self::parse_css2( $query ) : self::parse_css1( $query );
+                        if ( null === $parsed ) {
+                                continue; // unsupported form — keep as-is.
+                        }
+                        if ( '' === $orig_display && preg_match( '/(?:^|&)display=([a-z]+)/i', $query, $d ) ) {
+                                $orig_display = strtolower( $d[1] );
+                        }
+                        foreach ( $parsed as $name => $spec ) {
+                                if ( ! isset( $families[ $name ] ) ) {
+                                        $families[ $name ] = array( 'normal' => array(), 'italic' => array(), 'raw' => null );
+                                }
+                                if ( null !== $spec['raw'] ) {
+                                        $families[ $name ]['raw'] = $spec['raw'];
+                                }
+                                $families[ $name ]['normal'] += $spec['normal'];
+                                $families[ $name ]['italic'] += $spec['italic'];
+                        }
+                        $links[] = $tag;
+                }
+
+                if ( empty( $links ) ) {
+                        return $html;
+                }
+                $trim = (bool) $this->option( 'trim_weights', true );
+                // One link and nothing to trim — nothing to gain.
+                if ( 1 === count( $links ) && ! $trim ) {
+                        return $html;
+                }
+
+                $used = $trim ? $this->used_font_weights( $html ) : null;
+
+                $params = array();
+                foreach ( $families as $name => $spec ) {
+                        $params[] = 'family=' . str_replace( '%20', '+', rawurlencode( $name ) ) . self::css2_axis( $spec, $used );
+                }
+                $disp = '' !== $display ? $display : $orig_display;
+                if ( '' !== $disp ) {
+                        $params[] = 'display=' . $disp;
+                }
+                $url = 'https://fonts.googleapis.com/css2?' . implode( '&', $params );
+                // phpcs:ignore WordPress.WP.EnqueuedResources.NonEnqueuedStylesheet -- rewriting existing output-buffer markup, not enqueueing.
+                $new = '<link rel="stylesheet" id="optimazz-google-fonts" href="' . esc_url( $url ) . '" media="all">';
+
+                // Swap the first link for the merged one; remove the rest (each once).
+                $first = true;
+                foreach ( $links as $tag ) {
+                        $pos = strpos( $html, $tag );
+                        if ( false === $pos ) {
+                                continue;
+                        }
+                        $html  = substr_replace( $html, $first ? $new : '', $pos, strlen( $tag ) );
+                        $first = false;
+                }
+                return $html;
+        }
+
+        /**
+         * Parse a legacy CSS API query (`family=Inter:400,700i|Roboto&subset=…`).
+         *
+         * @param string $query URL query string.
+         * @return array|null Families, or null when the form is unsupported.
+         */
+        private static function parse_css1( $query ) {
+                $out = array();
+                foreach ( explode( '&', $query ) as $pair ) {
+                        $kv  = explode( '=', $pair, 2 );
+                        $key = strtolower( $kv[0] );
+                        if ( 'text' === $key ) {
+                                return null; // subset-by-text requests must stay exact.
+                        }
+                        if ( 'family' !== $key || ! isset( $kv[1] ) ) {
+                                continue;
+                        }
+                        foreach ( explode( '|', urldecode( $kv[1] ) ) as $fam ) {
+                                $parts = explode( ':', $fam, 2 );
+                                $name  = trim( $parts[0] );
+                                if ( '' === $name ) {
+                                        continue;
+                                }
+                                $spec = array( 'normal' => array(), 'italic' => array(), 'raw' => null );
+                                $vars = isset( $parts[1] ) ? explode( ',', $parts[1] ) : array( '400' );
+                                foreach ( $vars as $v ) {
+                                        $v = strtolower( trim( $v ) );
+                                        if ( '' === $v ) {
+                                                continue;
+                                        }
+                                        $v    = strtr( $v, array( 'regular' => '400', 'bold' => '700' ) );
+                                        $ital = (bool) preg_match( '/(italic|i)$/', $v );
+                                        $w    = (int) preg_replace( '/\D/', '', $v );
+                                        $w    = $w ? $w : 400; // bare "italic".
+                                        if ( $w < 100 || $w > 900 ) {
+                                                continue;
+                                        }
+                                        $spec[ $ital ? 'italic' : 'normal' ][ $w ] = 1;
+                                }
+                                if ( empty( $spec['normal'] ) && empty( $spec['italic'] ) ) {
+                                        $spec['normal'][400] = 1;
+                                }
+                                $out[ $name ] = $spec;
+                        }
+                }
+                return $out ? $out : null;
+        }
+
+        /**
+         * Parse a CSS2 API query (`family=Inter:ital,wght@0,400;1,700&family=…`).
+         *
+         * @param string $query URL query string.
+         * @return array|null Families, or null when the form is unsupported.
+         */
+        private static function parse_css2( $query ) {
+                $out = array();
+                foreach ( explode( '&', $query ) as $pair ) {
+                        $kv  = explode( '=', $pair, 2 );
+                        $key = strtolower( $kv[0] );
+                        if ( 'text' === $key ) {
+                                return null;
+                        }
+                        if ( 'family' !== $key || ! isset( $kv[1] ) ) {
+                                continue;
+                        }
+                        $fam   = urldecode( $kv[1] );
+                        $parts = explode( ':', $fam, 2 );
+                        $name  = trim( $parts[0] );
+                        if ( '' === $name ) {
+                                continue;
+                        }
+                        $spec = array( 'normal' => array(), 'italic' => array(), 'raw' => null );
+                        if ( ! isset( $parts[1] ) ) {
+                                $spec['normal'][400] = 1;
+                        } elseif ( preg_match( '/^ital,wght@(.+)$/', $parts[1], $m ) && false === strpos( $m[1], '..' ) ) {
+                                foreach ( explode( ';', $m[1] ) as $t ) {
+                                        $b = explode( ',', $t );
+                                        if ( 2 === count( $b ) ) {
+                                                $spec[ '1' === trim( $b[0] ) ? 'italic' : 'normal' ][ (int) $b[1] ] = 1;
+                                        }
+                                }
+                        } elseif ( preg_match( '/^wght@(.+)$/', $parts[1], $m ) && false === strpos( $m[1], '..' ) ) {
+                                foreach ( explode( ';', $m[1] ) as $w ) {
+                                        $spec['normal'][ (int) $w ] = 1;
+                                }
+                        } else {
+                                $spec['raw'] = $parts[1]; // variable ranges / other axes — keep verbatim.
+                        }
+                        unset( $spec['normal'][0], $spec['italic'][0] );
+                        $out[ $name ] = $spec;
+                }
+                return $out ? $out : null;
+        }
+
+        /**
+         * Build the CSS2 axis suffix for one family, trimmed to the used weights.
+         *
+         * @param array      $spec Family spec.
+         * @param array|null $used ['weights'=>[w=>1], 'italic'=>bool] or null (no trim).
+         * @return string e.g. ":ital,wght@0,400;0,700;1,400" or ":wght@400;700" or "".
+         */
+        private static function css2_axis( array $spec, $used ) {
+                if ( null !== $spec['raw'] ) {
+                        return ':' . $spec['raw'];
+                }
+                $normal = $spec['normal'];
+                $italic = $spec['italic'];
+                if ( is_array( $used ) ) {
+                        $n = array_intersect_key( $normal, $used['weights'] );
+                        $i = $used['italic'] ? array_intersect_key( $italic, $used['weights'] ) : array();
+                        // Never trim a family down to nothing — keep the original request.
+                        if ( ! empty( $n ) || ! empty( $i ) ) {
+                                $normal = $n;
+                                $italic = $i;
+                        }
+                }
+                ksort( $normal );
+                ksort( $italic );
+                if ( empty( $italic ) ) {
+                        if ( array( 400 ) === array_keys( $normal ) ) {
+                                return '';
+                        }
+                        return ':wght@' . implode( ';', array_keys( $normal ) );
+                }
+                $tuples = array();
+                foreach ( array_keys( $normal ) as $w ) {
+                        $tuples[] = '0,' . $w;
+                }
+                foreach ( array_keys( $italic ) as $w ) {
+                        $tuples[] = '1,' . $w;
+                }
+                return ':ital,wght@' . implode( ';', $tuples );
+        }
+
+        /**
+         * Work out which font weights (and whether italics) the page can actually
+         * render, from the page's own markup/inline CSS plus its local stylesheets.
+         * Deliberately conservative: 400 and 700 are always kept (default text and
+         * <strong>/<b>/headings), and any weight mentioned anywhere is kept.
+         *
+         * @param string $html Page HTML.
+         * @return array ['weights'=>[w=>1], 'italic'=>bool]
+         */
+        private function used_font_weights( $html ) {
+                $weights = array( 400 => 1, 700 => 1 );
+                $italic  = (bool) preg_match( '#<(em|cite|dfn|var|address)\b|<i>#i', $html );
+
+                self::scan_weights( $html, $weights, $italic );
+
+                // Local stylesheets: scanned once per set of files (cached until any of
+                // them changes), so this adds nothing to normal page views.
+                $files = array();
+                if ( preg_match_all( '#<link\b[^>]*\brel\s*=\s*["\']?stylesheet[^>]*>#i', $html, $lm ) ) {
+                        foreach ( $lm[0] as $tag ) {
+                                if ( ! preg_match( '#\bhref\s*=\s*["\']([^"\']+)#i', $tag, $h ) ) {
+                                        continue;
+                                }
+                                $path = Paths::url_to_path( html_entity_decode( $h[1], ENT_QUOTES ) );
+                                if ( $path && is_readable( $path ) && filesize( $path ) < 2097152 ) {
+                                        $files[ $path ] = (int) filemtime( $path );
+                                }
+                                if ( count( $files ) >= 80 ) {
+                                        break;
+                                }
+                        }
+                }
+                if ( $files ) {
+                        $key    = 'optimazz_fw_' . md5( wp_json_encode( $files ) );
+                        $cached = get_transient( $key );
+                        if ( is_array( $cached ) && isset( $cached['w'] ) ) {
+                                $weights += $cached['w'];
+                                $italic   = $italic || ! empty( $cached['i'] );
+                        } else {
+                                $fw = array();
+                                $fi = false;
+                                foreach ( array_keys( $files ) as $path ) {
+                                        self::scan_weights( (string) @file_get_contents( $path ), $fw, $fi ); // phpcs:ignore WordPress.WP.AlternativeFunctions,WordPress.PHP.NoSilencedErrors
+                                }
+                                set_transient( $key, array( 'w' => $fw, 'i' => $fi ), DAY_IN_SECONDS );
+                                $weights += $fw;
+                                $italic   = $italic || $fi;
+                        }
+                }
+
+                return array(
+                        'weights' => $weights,
+                        'italic'  => $italic,
+                );
+        }
+
+        /**
+         * Collect font-weight values and italic usage from CSS/markup text.
+         *
+         * @param string $text    CSS or HTML.
+         * @param array  $weights Weight set (by reference).
+         * @param bool   $italic  Italic flag (by reference).
+         * @return void
+         */
+        private static function scan_weights( $text, array &$weights, &$italic ) {
+                if ( preg_match_all( '/font-weight\s*:\s*([1-9]00|bold|normal)\b/i', $text, $m ) ) {
+                        foreach ( $m[1] as $v ) {
+                                $v = strtolower( $v );
+                                $w = 'bold' === $v ? 700 : ( 'normal' === $v ? 400 : (int) $v );
+                                $weights[ $w ] = 1;
+                        }
+                }
+                // Shorthand, e.g. "font: italic 600 1rem/1.4 Inter".
+                if ( preg_match_all( '/\bfont\s*:\s*[^;}{]*?\b([1-9]00)\b/i', $text, $m ) ) {
+                        foreach ( $m[1] as $v ) {
+                                $weights[ (int) $v ] = 1;
+                        }
+                }
+                if ( ! $italic && preg_match( '/font-style\s*:\s*italic|\bfont\s*:[^;}{]*\bitalic\b/i', $text ) ) {
+                        $italic = true;
+                }
+        }
+
         /**
          * Guess the MIME type for a font URL.