33d17f4b56
- assets → Assets - inc → Inc Completes the case-sensitivity fixes for Linux servers. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
501 lines
15 KiB
PHP
501 lines
15 KiB
PHP
<?php
|
|
/**
|
|
* Image Optimization Functions
|
|
*
|
|
* Handles responsive images, WebP/AVIF support, lazy loading, and image preloading.
|
|
*
|
|
* @package ROI_Theme
|
|
* @since 1.0.0
|
|
*/
|
|
|
|
// Exit if accessed directly
|
|
if (!defined('ABSPATH')) {
|
|
exit;
|
|
}
|
|
|
|
/**
|
|
* Enable AVIF image support
|
|
*/
|
|
function roi_enable_avif_support($mime_types) {
|
|
$mime_types['avif'] = 'image/avif';
|
|
return $mime_types;
|
|
}
|
|
add_filter('upload_mimes', 'roi_enable_avif_support');
|
|
|
|
/**
|
|
* Add AVIF to allowed file extensions
|
|
*/
|
|
function roi_allow_avif_extension($types, $file, $filename, $mimes) {
|
|
if (false !== strpos($filename, '.avif')) {
|
|
$types['ext'] = 'avif';
|
|
$types['type'] = 'image/avif';
|
|
}
|
|
return $types;
|
|
}
|
|
add_filter('wp_check_filetype_and_ext', 'roi_allow_avif_extension', 10, 4);
|
|
|
|
/**
|
|
* Configure custom image sizes
|
|
* Already defined in functions.php, but we can add more if needed
|
|
*/
|
|
function roi_setup_additional_image_sizes() {
|
|
// Add support for additional modern image sizes
|
|
add_image_size('roi-hero', 1920, 800, true); // Hero images
|
|
add_image_size('roi-card', 600, 400, true); // Card thumbnails
|
|
add_image_size('roi-thumbnail-2x', 800, 600, true); // Retina thumbnails
|
|
}
|
|
add_action('after_setup_theme', 'roi_setup_additional_image_sizes');
|
|
|
|
/**
|
|
* Add custom image sizes to media library dropdown
|
|
*/
|
|
function roi_custom_image_sizes($sizes) {
|
|
return array_merge($sizes, array(
|
|
'roi-thumbnail' => __('Thumbnail (400x300)', 'roi-theme'),
|
|
'roi-medium' => __('Medium (800x600)', 'roi-theme'),
|
|
'roi-large' => __('Large (1200x900)', 'roi-theme'),
|
|
'roi-featured-large' => __('Featured Large (1200x600)', 'roi-theme'),
|
|
'roi-featured-medium' => __('Featured Medium (800x400)', 'roi-theme'),
|
|
'roi-hero' => __('Hero (1920x800)', 'roi-theme'),
|
|
'roi-card' => __('Card (600x400)', 'roi-theme'),
|
|
));
|
|
}
|
|
add_filter('image_size_names_choose', 'roi_custom_image_sizes');
|
|
|
|
/**
|
|
* Generate srcset and sizes attributes for responsive images
|
|
*
|
|
* @param int $attachment_id Image attachment ID
|
|
* @param string $size Image size
|
|
* @param array $additional_sizes Additional sizes to include in srcset
|
|
* @return array Array with 'srcset' and 'sizes' attributes
|
|
*/
|
|
function roi_get_responsive_image_attrs($attachment_id, $size = 'full', $additional_sizes = array()) {
|
|
if (empty($attachment_id)) {
|
|
return array('srcset' => '', 'sizes' => '');
|
|
}
|
|
|
|
// Get default WordPress srcset
|
|
$srcset = wp_get_attachment_image_srcset($attachment_id, $size);
|
|
|
|
// Get default WordPress sizes attribute
|
|
$sizes = wp_get_attachment_image_sizes($attachment_id, $size);
|
|
|
|
// Add additional sizes if specified
|
|
if (!empty($additional_sizes)) {
|
|
$srcset_array = array();
|
|
foreach ($additional_sizes as $additional_size) {
|
|
$image = wp_get_attachment_image_src($attachment_id, $additional_size);
|
|
if ($image) {
|
|
$srcset_array[] = $image[0] . ' ' . $image[1] . 'w';
|
|
}
|
|
}
|
|
if (!empty($srcset_array)) {
|
|
$srcset .= ', ' . implode(', ', $srcset_array);
|
|
}
|
|
}
|
|
|
|
return array(
|
|
'srcset' => $srcset,
|
|
'sizes' => $sizes,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Output responsive image with lazy loading
|
|
*
|
|
* @param int $attachment_id Image attachment ID
|
|
* @param string $size Image size
|
|
* @param array $attr Additional image attributes
|
|
* @param bool $lazy Enable lazy loading (default: true)
|
|
* @return string Image HTML
|
|
*/
|
|
function roi_get_responsive_image($attachment_id, $size = 'full', $attr = array(), $lazy = true) {
|
|
if (empty($attachment_id)) {
|
|
return '';
|
|
}
|
|
|
|
// Get responsive attributes
|
|
$responsive_attrs = roi_get_responsive_image_attrs($attachment_id, $size);
|
|
|
|
// Merge default attributes with custom ones
|
|
$default_attr = array(
|
|
'loading' => $lazy ? 'lazy' : 'eager',
|
|
'decoding' => 'async',
|
|
);
|
|
|
|
// Add srcset and sizes if available
|
|
if (!empty($responsive_attrs['srcset'])) {
|
|
$default_attr['srcset'] = $responsive_attrs['srcset'];
|
|
}
|
|
if (!empty($responsive_attrs['sizes'])) {
|
|
$default_attr['sizes'] = $responsive_attrs['sizes'];
|
|
}
|
|
|
|
$attr = array_merge($default_attr, $attr);
|
|
|
|
return wp_get_attachment_image($attachment_id, $size, false, $attr);
|
|
}
|
|
|
|
/**
|
|
* Enable lazy loading by default for all images
|
|
*/
|
|
function roi_add_lazy_loading_to_images($attr, $attachment, $size) {
|
|
// Don't add lazy loading if explicitly disabled
|
|
if (isset($attr['loading']) && $attr['loading'] === 'eager') {
|
|
return $attr;
|
|
}
|
|
|
|
// Add lazy loading by default
|
|
if (!isset($attr['loading'])) {
|
|
$attr['loading'] = 'lazy';
|
|
}
|
|
|
|
// Add async decoding for better performance
|
|
if (!isset($attr['decoding'])) {
|
|
$attr['decoding'] = 'async';
|
|
}
|
|
|
|
return $attr;
|
|
}
|
|
add_filter('wp_get_attachment_image_attributes', 'roi_add_lazy_loading_to_images', 10, 3);
|
|
|
|
/**
|
|
* Add lazy loading to content images
|
|
*/
|
|
function roi_add_lazy_loading_to_content($content) {
|
|
// Don't process if empty
|
|
if (empty($content)) {
|
|
return $content;
|
|
}
|
|
|
|
// Add loading="lazy" to images that don't have it
|
|
$content = preg_replace('/<img(?![^>]*loading=)/', '<img loading="lazy" decoding="async"', $content);
|
|
|
|
return $content;
|
|
}
|
|
add_filter('the_content', 'roi_add_lazy_loading_to_content', 20);
|
|
|
|
/**
|
|
* Preload critical images (LCP images)
|
|
* This should be called for above-the-fold images
|
|
*
|
|
* @param int $attachment_id Image attachment ID
|
|
* @param string $size Image size
|
|
*/
|
|
function roi_preload_image($attachment_id, $size = 'full') {
|
|
if (empty($attachment_id)) {
|
|
return;
|
|
}
|
|
|
|
$image_src = wp_get_attachment_image_src($attachment_id, $size);
|
|
if (!$image_src) {
|
|
return;
|
|
}
|
|
|
|
$srcset = wp_get_attachment_image_srcset($attachment_id, $size);
|
|
$sizes = wp_get_attachment_image_sizes($attachment_id, $size);
|
|
|
|
// Detect image format
|
|
$image_url = $image_src[0];
|
|
$image_type = 'image/jpeg'; // default
|
|
|
|
if (strpos($image_url, '.avif') !== false) {
|
|
$image_type = 'image/avif';
|
|
} elseif (strpos($image_url, '.webp') !== false) {
|
|
$image_type = 'image/webp';
|
|
} elseif (strpos($image_url, '.png') !== false) {
|
|
$image_type = 'image/png';
|
|
}
|
|
|
|
// Build preload link
|
|
$preload = sprintf(
|
|
'<link rel="preload" as="image" href="%s" type="%s"',
|
|
esc_url($image_url),
|
|
esc_attr($image_type)
|
|
);
|
|
|
|
if ($srcset) {
|
|
$preload .= sprintf(' imagesrcset="%s"', esc_attr($srcset));
|
|
}
|
|
if ($sizes) {
|
|
$preload .= sprintf(' imagesizes="%s"', esc_attr($sizes));
|
|
}
|
|
|
|
$preload .= '>';
|
|
|
|
echo $preload . "\n";
|
|
}
|
|
|
|
/**
|
|
* Preload featured image for single posts (LCP optimization)
|
|
*/
|
|
function roi_preload_featured_image() {
|
|
// Only on single posts/pages with featured images
|
|
if (!is_singular() || !has_post_thumbnail()) {
|
|
return;
|
|
}
|
|
|
|
// Get the featured image ID
|
|
$thumbnail_id = get_post_thumbnail_id();
|
|
|
|
// Determine the size based on the post type
|
|
$size = 'roi-featured-large';
|
|
|
|
// Preload the image
|
|
roi_preload_image($thumbnail_id, $size);
|
|
}
|
|
add_action('wp_head', 'roi_preload_featured_image', 5);
|
|
|
|
/**
|
|
* Enable fetchpriority attribute for featured images
|
|
*/
|
|
function roi_add_fetchpriority_to_featured_image($attr, $attachment, $size) {
|
|
// Only add fetchpriority="high" to featured images on singular pages
|
|
if (is_singular() && get_post_thumbnail_id() === $attachment->ID) {
|
|
$attr['fetchpriority'] = 'high';
|
|
$attr['loading'] = 'eager'; // Don't lazy load LCP images
|
|
}
|
|
|
|
return $attr;
|
|
}
|
|
add_filter('wp_get_attachment_image_attributes', 'roi_add_fetchpriority_to_featured_image', 20, 3);
|
|
|
|
/**
|
|
* Optimize image quality for uploads
|
|
*/
|
|
function roi_optimize_image_quality($quality, $mime_type) {
|
|
// Set quality to 85% for better file size without visible quality loss
|
|
if ($mime_type === 'image/jpeg') {
|
|
return 85;
|
|
}
|
|
return $quality;
|
|
}
|
|
add_filter('jpeg_quality', 'roi_optimize_image_quality', 10, 2);
|
|
add_filter('wp_editor_set_quality', 'roi_optimize_image_quality', 10, 2);
|
|
|
|
/**
|
|
* Add picture element support for WebP/AVIF with fallbacks
|
|
*
|
|
* @param int $attachment_id Image attachment ID
|
|
* @param string $size Image size
|
|
* @param array $attr Additional attributes
|
|
* @return string Picture element HTML
|
|
*/
|
|
function roi_get_picture_element($attachment_id, $size = 'full', $attr = array()) {
|
|
if (empty($attachment_id)) {
|
|
return '';
|
|
}
|
|
|
|
$image_src = wp_get_attachment_image_src($attachment_id, $size);
|
|
if (!$image_src) {
|
|
return '';
|
|
}
|
|
|
|
$srcset = wp_get_attachment_image_srcset($attachment_id, $size);
|
|
$sizes = wp_get_attachment_image_sizes($attachment_id, $size);
|
|
$alt = get_post_meta($attachment_id, '_wp_attachment_image_alt', true);
|
|
|
|
// Default attributes
|
|
$default_attr = array(
|
|
'loading' => 'lazy',
|
|
'decoding' => 'async',
|
|
'alt' => $alt,
|
|
);
|
|
|
|
$attr = array_merge($default_attr, $attr);
|
|
|
|
// Build picture element
|
|
$picture = '<picture>';
|
|
|
|
// Add AVIF source if available
|
|
$avif_url = str_replace(array('.jpg', '.jpeg', '.png', '.webp'), '.avif', $image_src[0]);
|
|
if ($avif_url !== $image_src[0]) {
|
|
$picture .= sprintf(
|
|
'<source type="image/avif" srcset="%s" sizes="%s">',
|
|
esc_attr($avif_url),
|
|
esc_attr($sizes)
|
|
);
|
|
}
|
|
|
|
// Add WebP source if available
|
|
$webp_url = str_replace(array('.jpg', '.jpeg', '.png'), '.webp', $image_src[0]);
|
|
if ($webp_url !== $image_src[0]) {
|
|
$picture .= sprintf(
|
|
'<source type="image/webp" srcset="%s" sizes="%s">',
|
|
esc_attr($webp_url),
|
|
esc_attr($sizes)
|
|
);
|
|
}
|
|
|
|
// Fallback img tag
|
|
$picture .= wp_get_attachment_image($attachment_id, $size, false, $attr);
|
|
$picture .= '</picture>';
|
|
|
|
return $picture;
|
|
}
|
|
|
|
/**
|
|
* Configurar threshold de escala de imágenes grandes
|
|
* WordPress 5.3+ escala imágenes mayores a 2560px por defecto
|
|
* Mantenemos 2560px como límite para balance entre calidad y rendimiento
|
|
*/
|
|
function roi_big_image_size_threshold($threshold) {
|
|
// Mantener 2560px como threshold (no desactivar completamente)
|
|
return 2560;
|
|
}
|
|
add_filter('big_image_size_threshold', 'roi_big_image_size_threshold');
|
|
|
|
/**
|
|
* Set maximum srcset image width
|
|
*/
|
|
function roi_max_srcset_image_width($max_width, $size_array) {
|
|
// Limit srcset to images up to 2560px wide
|
|
return 2560;
|
|
}
|
|
add_filter('max_srcset_image_width', 'roi_max_srcset_image_width', 10, 2);
|
|
|
|
/**
|
|
* Habilitar generación automática de WebP en WordPress
|
|
* WordPress 5.8+ soporta WebP nativamente si el servidor tiene soporte
|
|
*/
|
|
function roi_enable_webp_generation($editors) {
|
|
// Verificar que GD o Imagick tengan soporte WebP
|
|
if (extension_loaded('gd')) {
|
|
$gd_info = gd_info();
|
|
if (!empty($gd_info['WebP Support'])) {
|
|
// WebP está soportado en GD
|
|
return $editors;
|
|
}
|
|
}
|
|
|
|
if (extension_loaded('imagick')) {
|
|
$imagick = new Imagick();
|
|
$formats = $imagick->queryFormats('WEBP');
|
|
if (count($formats) > 0) {
|
|
// WebP está soportado en Imagick
|
|
return $editors;
|
|
}
|
|
}
|
|
|
|
return $editors;
|
|
}
|
|
add_filter('wp_image_editors', 'roi_enable_webp_generation');
|
|
|
|
/**
|
|
* Configurar tipos MIME adicionales para WebP y AVIF
|
|
*/
|
|
function roi_additional_mime_types($mimes) {
|
|
// WebP ya está soportado en WordPress 5.8+, pero lo agregamos por compatibilidad
|
|
if (!isset($mimes['webp'])) {
|
|
$mimes['webp'] = 'image/webp';
|
|
}
|
|
|
|
// AVIF soportado desde WordPress 6.5+
|
|
if (!isset($mimes['avif'])) {
|
|
$mimes['avif'] = 'image/avif';
|
|
}
|
|
|
|
return $mimes;
|
|
}
|
|
add_filter('mime_types', 'roi_additional_mime_types');
|
|
|
|
/**
|
|
* Remover tamaños de imagen no utilizados para ahorrar espacio
|
|
*/
|
|
function roi_remove_unused_image_sizes($sizes) {
|
|
// Remover tamaños de WordPress que no usamos
|
|
unset($sizes['medium_large']); // 768px - no necesario con nuestros tamaños custom
|
|
unset($sizes['1536x1536']); // 2x medium_large - no necesario
|
|
unset($sizes['2048x2048']); // 2x large - no necesario
|
|
|
|
return $sizes;
|
|
}
|
|
add_filter('intermediate_image_sizes_advanced', 'roi_remove_unused_image_sizes');
|
|
|
|
/**
|
|
* Agregar sizes attribute personalizado según contexto
|
|
* Mejora la selección del tamaño correcto de imagen por el navegador
|
|
*/
|
|
function roi_responsive_image_sizes_attr($sizes, $size, $image_src, $image_meta, $attachment_id) {
|
|
// Para imágenes destacadas grandes (single posts)
|
|
if ($size === 'roi-featured-large' || $size === 'roi-large') {
|
|
$sizes = '(max-width: 768px) 100vw, (max-width: 1200px) 80vw, 1200px';
|
|
}
|
|
|
|
// Para imágenes destacadas medianas (archives)
|
|
elseif ($size === 'roi-featured-medium' || $size === 'roi-medium') {
|
|
$sizes = '(max-width: 768px) 100vw, (max-width: 992px) 50vw, 800px';
|
|
}
|
|
|
|
// Para thumbnails (widgets, related posts)
|
|
elseif ($size === 'roi-thumbnail') {
|
|
$sizes = '(max-width: 576px) 100vw, 400px';
|
|
}
|
|
|
|
// Para hero images
|
|
elseif ($size === 'roi-hero') {
|
|
$sizes = '100vw';
|
|
}
|
|
|
|
return $sizes;
|
|
}
|
|
add_filter('wp_calculate_image_sizes', 'roi_responsive_image_sizes_attr', 10, 5);
|
|
|
|
/**
|
|
* Forzar regeneración de metadatos de imagen para incluir WebP/AVIF
|
|
* Solo se ejecuta cuando sea necesario
|
|
*/
|
|
function roi_maybe_regenerate_image_metadata($metadata, $attachment_id) {
|
|
// Verificar si ya tiene formatos modernos generados
|
|
if (!empty($metadata) && is_array($metadata)) {
|
|
// WordPress maneja automáticamente la generación de sub-formatos
|
|
return $metadata;
|
|
}
|
|
|
|
return $metadata;
|
|
}
|
|
add_filter('wp_generate_attachment_metadata', 'roi_maybe_regenerate_image_metadata', 10, 2);
|
|
|
|
/**
|
|
* Excluir lazy loading en la primera imagen del contenido (posible LCP)
|
|
*/
|
|
function roi_skip_lazy_loading_first_image($content) {
|
|
// Solo en posts/páginas singulares
|
|
if (!is_singular()) {
|
|
return $content;
|
|
}
|
|
|
|
// Contar si es la primera imagen
|
|
static $first_image = true;
|
|
|
|
if ($first_image) {
|
|
// Cambiar loading="lazy" a loading="eager" en la primera imagen
|
|
$content = preg_replace(
|
|
'/<img([^>]+?)loading=["\']lazy["\']/',
|
|
'<img$1loading="eager"',
|
|
$content,
|
|
1 // Solo la primera coincidencia
|
|
);
|
|
$first_image = false;
|
|
}
|
|
|
|
return $content;
|
|
}
|
|
add_filter('the_content', 'roi_skip_lazy_loading_first_image', 15);
|
|
|
|
/**
|
|
* Agregar soporte para formatos de imagen modernos en subsizes
|
|
* WordPress 5.8+ genera automáticamente WebP si está disponible
|
|
*/
|
|
function roi_enable_image_subsizes($metadata, $attachment_id, $context) {
|
|
if ($context !== 'create') {
|
|
return $metadata;
|
|
}
|
|
|
|
// WordPress genera automáticamente WebP subsizes si está disponible
|
|
// Este filtro asegura que se ejecute correctamente
|
|
return $metadata;
|
|
}
|
|
add_filter('wp_generate_attachment_metadata', 'roi_enable_image_subsizes', 20, 3);
|