Blog de Notas

Cuando trabajamos en el desarrollo o rediseño de una web WordPress, es fundamental controlar quién puede ver el sitio antes de su publicación. Tanto si quieres que solo los administradores accedan al sitio, como si prefieres mostrar el resultado a un cliente (o grupo de usuarios registrados), existen soluciones sencillas en código que te evitan instalar plugins innecesarios.

Por qué evitar los plugins de mantenimiento para tareas simples

Como desarrollador WordPress, soy un convencido de que cuantos menos plugins, mejor. Los populares plugins de “modo mantenimiento” pueden dejar rastros en la base de datos o incluso archivos en el servidor tras ser desinstalados. Además, para tareas tan específicas como bloquear el acceso durante el desarrollo, son claramente un “overkill”.

En vez de cargar tu WordPress con plugins para tareas pequeñas, te propongo dos snippets funcionales, limpios y fácilmente personalizables.

Opción 1: Solo acceso a administradores

Este código permite que únicamente los usuarios con rol administrator puedan ver la web. El resto de usuarios (y visitantes no logueados) serán redirigidos a la URL que definas:

add_action( 'template_redirect', function() {
    if ( ! current_user_can( 'administrator' ) && ! is_admin() && ! wp_doing_ajax() ) :
        wp_redirect( 'https://www.DOMAIN.com/' );
        exit;
    endif;
} );

¿Cómo funciona?

• Comprueba si el usuario no es administrador (! current_user_can( 'administrator' ) ), si no está en el admin ( ! is_admin() ), ni es una petición AJAX ( ! wp_doing_ajax() ).
• Si no cumple estos requisitos, lo redirige fuera del sitio.

Personalización:

Puedes adaptarlo a otros roles. Por ejemplo, para permitir acceso a editores y administradores:

if (
  ! current_user_can( 'administrator' ) &&
  ! current_user_can( 'editor' ) &&
  ! is_admin() && ! wp_doing_ajax()
)

Añade tantos roles como necesites.

Opción 2: Acceso a cualquier usuario registrado

Perfecta si necesitas que tu cliente (o cualquier usuario registrado) pueda ver la web en desarrollo, independientemente de su perfil:

add_action( 'template_redirect', function() {
    if ( ! is_user_logged_in() && ! is_admin() && ! wp_doing_ajax() ) :
        wp_redirect( 'https://www.DOMAIN.com/' );
        exit;
    endif;
} );

¿Cuándo la uso? La suelo usar cuando quiero enseñar la web al cliente, especialmente si tiene varios usuarios con diferentes roles (shop manager, editor, etc.).

¿A dónde redirigir?

• Rediseño de web: Yo suelo redirigir a la web en producción.
• Sitio nuevo: Puedes crear una landing HTML sencilla en el mismo servidor y redirigir ahí hasta que la web esté lista.

Recuerda: Sustituye https://www.DOMAIN.com/ por la URL real donde quieras enviar a los visitantes no autorizados.

Ventajas de este enfoque

• Sin plugins: Nada que limpiar tras activar la web definitiva.
• Personalizable: Puedes filtrar por cualquier rol, incluso añadir condiciones extra si lo necesitas.
• Sencillo y reversible: Solo tienes que eliminar el snippet para abrir el sitio al mundo.

  Resumiendo

  Usar estos snippets de WordPress para bloquear el acceso durante el desarrollo es la forma más limpia y segura de trabajar. Evitas plugins de mantenimiento que pueden dejar residuos, mantienes el control absoluto sobre quién puede ver el sitio, y te adaptas fácilmente a las necesidades de cada proyecto o cliente.

Si has visto este notice en tu instalación de WordPress:

La función _load_textdomain_just_in_time ha sido llamada de forma incorrecta. La carga de la traducción para el dominio ciclo se activó demasiado pronto.

entonces estás usando funciones de traducción como __() o _e() antes de tiempo, es decir, antes del hook init.

¿Por qué ocurre?

WordPress necesita que los archivos de traducción (.mo) se carguen después de que el sistema esté inicializado. Si ejecutas algo como esto directamente en el functions.php o en un plugin:

define( 'MY_LABEL', __( 'Some text', 'my_textdomain' ) );

WordPress todavía no tiene listo el sistema de traducción, y lanza el notice.

¿Cómo solucionarlo?

Usa funciones de traducción solo dentro de hooks (init, after_setup_theme, etc.). O guarda strings sin traducir, y tradúcelos cuando los vayas a mostrar. Ejemplo correcto:

add_action( 'init', function() {
    define( 'MY_LABEL', __( 'Some text', 'my_textdomain' ) );
} );

Cómo depurar el error con un plugin de ayuda

Cuando tienes muchos archivos y no sabes dónde se está usando mal __(), puedes usar este plugin temporal para detectar el origen exacto:

Paso 1: Crea el plugin en wp-content/plugins/debug-textdomain-loader.php

/**
 * Plugin Name: Debug Textdomain Loader
 */
add_filter( 'override_load_textdomain', function( $override, $domain ) {
    if ( $domain === 'my_textdomain' ) {
        error_log( "⚠️ Dominio '$domain' intentado cargar demasiado pronto" );
        error_log( print_r( debug_backtrace( DEBUG_BACKTRACE_IGNORE_ARGS ), true ) );
    }
    return false;
}, 1, 2 );

Paso 2: Asegúrate de tener la depuración activa

En tu wp-config.php:

define( 'WP_DEBUG', true );
define( 'WP_DEBUG_LOG', true );
define( 'WP_DEBUG_DISPLAY', true );

Paso 3: Activa el plugin y revisa wp-content/debug.log

Verás una traza completa con el archivo y línea exacta donde se ha intentado cargar el dominio de traducción demasiado pronto.

Conclusión

Este problema es muy común en temas o plugins personalizados, y suele pasar desapercibido hasta que actualizas WordPress a versiones más estrictas (como 6.7+) y activas el debug. La buena noticia es que tiene una solución sencilla y reutilizable.

Contabilizar las visitas a un post en WordPress es útil para obtener información sobre la interacción de los usuarios con el contenido. Este artículo te enseña cómo crear una función para incrementar el contador de visitas de un post y cómo implementarlo en tu sitio. La función tms_increase_visit_counter() tiene como objetivo incrementar el contador de visitas de un post cada vez que un usuario accede a él. Esta función guarda el número de visitas en los metadatos del post, permitiéndote realizar un seguimiento de la popularidad de cada artículo. El contador solo se incrementará para los usuarios no registrados o los que no tengan roles específicos excluidos, como administradores o editores.

Desglose del Código

Incrementar el Contador de Visitas

Obtención del Contador de Visitas: La función utiliza get_post_meta() para obtener el valor actual del contador de visitas de un post. Si no existe, se inicializa el contador con el valor 1.

$key   = 'tms_post_views_count';
$count = get_post_meta( $postID, $key, true );

Condición para Crear o Actualizar el Contador: Si el contador no está definido ($count == ''), elimina cualquier valor anterior y agrega uno nuevo con el valor 1. Si el contador ya existe, lo actualiza incrementando el valor en 1.

if ( $count == '' ) :
    delete_post_meta( $postID, $key );
    add_post_meta( $postID, $key, '1' );
else :
    update_post_meta( $postID, $key, $count + 1 );
endif;

Implementación en la Acción wp_head

Verificación de Página Única: La acción se ejecuta solo en páginas de post único (is_single()), evitando que se registre la visita en otras partes del sitio.

if ( ! is_single() ) return;

Condición de Usuario No Registrado: Si el usuario no está registrado, se incrementa el contador para la visita.

if ( ! is_user_logged_in() ) :
    tms_increase_visit_counter( $postID );
    return;

Exclusión de Roles Específicos: Si el usuario tiene un rol de administrador, editor o roles similares (como contributor o shop_manager), no se incrementa el contador de visitas.

$user           = wp_get_current_user();
$excluded_roles = ['administrator', 'editor', 'contributor', 'shop_manager', 'translator'];
if ( array_intersect( $excluded_roles, $user->roles ) ) return;

Incremento del Contador para Otros Usuarios: Si el usuario no tiene un rol excluido, se llama a la función tms_increase_visit_counter() para incrementar el contador.

tms_increase_visit_counter( $postID );

Código Completo

function tms_increase_visit_counter( $postID ) {
    $key   = 'tms_post_views_count';
    $count = get_post_meta( $postID, $key, true );

    if ( $count == '' ) :
        delete_post_meta( $postID, $key );
        add_post_meta( $postID, $key, '1' );
    else :
        update_post_meta( $postID, $key, $count + 1 );
    endif;
}

add_action( 'wp_head', function() {
    if ( ! is_single() ) return;
    if ( empty( get_post() ) ) return;
    $postID = get_the_ID();

    if ( ! is_user_logged_in() ) :
        tms_increase_visit_counter( $postID );
        return;
    endif;

    $user           = wp_get_current_user();
    $excluded_roles = ['administrator', 'editor', 'contributor', 'shop_manager', 'translator'];
    if ( array_intersect( $excluded_roles, $user->roles ) ) return;

    tms_increase_visit_counter( $postID );
} );

Con este código, puedes llevar un seguimiento sencillo de las visitas a tus publicaciones y excluir ciertos roles según sea necesario.

Evitando el uso de imágenes demasiado grandes en WordPress

Cuando desarrollamos una web en WordPress, lo hacemos pensando en la optimización de la misma web. Esa optimización pasa por ofrecer un buen rendimiento al usuario final de la página web.

Pero existe una realidad, tu entregas la web a tu cliente, le explicas que tamaños de imagen debe usar, pero muchas veces, luego hacen lo que quieren.

Seguro que te ha pasado más de una vez, que al cabo de un par de meses, el cliente te contacte para decirte que la web ahora es lenta, y tu entras y resulta que esta usando imágenes que son mucho más grandes de lo que la web necesita (yo he llegado a encontrarme imágenes de varios GB).

Si bien es cierto que con WordPress, al pintar la imagen podemos decirle que tamaño queremos que use, incluso podemos definir todos los tamaños que queramos con add_image_size(). Eso implica que por cada imagen que se suba se creará una copia en cada uno de los tamaños definidos. Y eso solo hace engordar el espacio del servidor con imágenes que nunca se van a usar.

Es por esto que intento limitar más esta práctica en mis proyectos. Primero lo hice usando las imagenes en «full» y diciéndole a mis clientes que medidas tenían que usar, pero como decía antes, esto no siempre funciona.

Cuando creas módulos o bloques con ACF puedes limitar el tamaño de las imágenes que soporta. ¿Pero qué pasa cuando no puedes limitarlo así?

Lo que se me ha ocurrido es crear una función que valide el tamaño de la imagen. Te explico cómo.

Desglosando el código para limitar el tamaño de las imágenes en el frontend de WordPress

Función Principal tms_validate_image_size()

La función tms_validate_image_size() permite validar si una imagen cumple con ciertas dimensiones específicas en términos de ancho y alto.

1. Recibe 3 parametros:
   • $attachment_id el ID de la imagen a comparar

   • $width, es un array opcional, soporta los valores size y operator.

   • $height, es un array opcional, soporta los valores size y operator.

2. Obtención de Metadatos de la Imagen: Se obtienen los metadatos de la imagen utilizando la función wp_get_attachment_metadata().

$image_meta = wp_get_attachment_metadata( $attachment_id );

3. Verificación de Dimensiones Proporcionadas: Se verifica si se han proporcionado valores para el ancho y el alto. Si están presentes, se comprueba si la imagen cumple con los requisitos dados.

if ( $width !== null && $height !== null ) :
elseif ( $width !== null ) :
elseif ( $height !== null ) :
endif;

4. Comparación de Ancho y/o Alto: Se compara el ancho y/o el alto de la imagen con los valores proporcionados utilizando la función auxiliar tms_compare_size_with_operator().

   • Ancho y Alto

   $width_check  = tms_compare_size_with_operator( $image_meta['width'], $width['size'], $width['operator'] );
   $height_check = tms_compare_size_with_operator( $image_meta['height'], $height['size'], $height['operator'] );
   if ( $width_check && $height_check ) :
       return true;
   endif;
   

   • Solo ancho

   $width_check = tms_compare_size_with_operator( $image_meta['width'], $width['size'], $width['operator'] );
   if ( $width_check ) :
       return true;
   endif;
   

   • Solo alto

   $height_check = tms_compare_size_with_operator( $image_meta['height'], $height['size'], $height['operator'] );
   if ( $height_check ) :
       return true;
   endif;
   

Función Auxiliar tms_compare_size_with_operator()

La función tms_compare_size_with_operator compara el tamaño real de la imagen con un tamaño objetivo utilizando un operador específico.

Esta función recibe 3 parametros:

1. $actual_size el tamaño de la imagen a comparar.

2. $target_size el tamaño que queremos comprar.

3. $operator es opcional, acepta diversas opciones(>, >=, <, <=, ==) y por defecto usa ==.

4. Comparación de Tamaño: Se realiza la comparación entre el tamaño real de la imagen y el tamaño objetivo utilizando el operador seleccionado, y se devuelve el resultado de la comparación.

Optimizando el rendimiento de WordPress limitando el Tamaño de las imagenes en el frontend

El codigo completo para copiar.

Genera un menú de cambio de idioma atractivo con WPML en WordPress

El propósito de este código es generar un menú de cambio de idioma en un sitio web utilizando el plugin de WordPress «WPML» (WordPress Multilingual Plugin).

Para el menú de cambio de idioma se utilizan los idiomas configurados en el plugin. Crea un menú desplegable con enlaces a cada idioma y resalta el idioma actualmente activo en el sitio.

Paso a paso: Código detallado para crear un menú multilingüe con WPML

1. La función tms_language_switcher está envuelta en una comprobación if ( ! function_exists( 'tms_language_switcher' ) ) para asegurarse de que no se produzca un conflicto si la función ya está definida en otro lugar.

if ( ! function_exists( 'tms_language_switcher' ) ) :
    function tms_language_switcher() {

2. La función comienza obteniendo la lista de idiomas disponibles utilizando la función icl_get_languages. Esta función es proporcionada por el plugin WPML y devuelve un array con información sobre cada idioma configurado en el sitio.

$languages = icl_get_languages( 'skip_missing=0' );

3. A continuación, se verifica si la lista de idiomas no está vacía.

if ( ! empty( $languages ) ) :

4. Si la lista de idiomas no está vacía, se inicia la generación del menú de cambio de idioma. Se utiliza un elemento <nav> con la clase «language-nav» para envolver el menú y se establece el atributo aria-label con el texto traducido «Language menu» para mejorar la accesibilidad. Dentro del </nav><nav>, se crea una lista desordenada <ul> con el id «menu-language» y la clase «menu» para representar los elementos del menú.

echo '<nav class="language-nav" role="navigation" aria-label="' . esc_attr__( 'Language menu', 'tms' ) . '">';
    echo '<ul id="menu-language" class="menu">';

5. Se recorre cada idioma en la lista de idiomas utilizando un bucle foreach. Para cada idioma, se verifica si está activo (es decir, el idioma actual del sitio) y se le asigna la clase «current-menu-item» si es así.

foreach ( $languages as $language ) :
    $current = 1 == $language['active'] ? ' current-menu-item' : '';

7. Para cada idioma, se genera un elemento de lista <li> con la clase «menu-item» y la clase «current-menu-item» si corresponde. Dentro de este elemento de lista, se crea un enlace <a> con el atributo href establecido en la URL del idioma y se muestra el código del idioma en mayúsculas utilizando strtoupper( $language['language_code'] ).

echo '<li class="menu-item' . $current . '">';
    echo '<a href="' . $language['url'] . '">';
        echo strtoupper( $language['language_code'] );
    echo '</a>';
echo '</li>';

8. Después de completar el bucle foreach y generar todos los elementos de lista para los idiomas, se cierra la lista desordenada </a></li></ul> y el </nav>.

    echo '</ul>';
echo '</nav>';

Código completo para copiar y crear un menú de cambio de idioma en WordPress con WPML

<?php
if ( ! function_exists( 'tms_language_switcher' ) ) :
    function tms_language_switcher() {

        $languages = icl_get_languages( 'skip_missing=0' );

        if ( ! empty( $languages ) ) :

            echo '<nav class="language-nav" role="navigation" aria-label="' . esc_attr__( 'Language menu', 'tms' ) . '">';

                echo '<ul id="menu-language" class="menu">';

                    foreach ( $languages as $language ) :

                        $current = 1 == $language['active'] ? ' current-menu-item' : '';

                        echo '<li class="menu-item' . $current . '">';
                            echo '<a href="' . $language['url'] . '">';
                                echo strtoupper( $language['language_code'] );
                            echo '</a>';
                        echo '</li>';

                    endforeach;

                echo '</ul>';

            echo '</nav>';

        endif;

    }
endif;

Solución para corregir la directiva ‘RewriteBase’ y el plugin WPML en WordPress

Este código en PHP es un fragmento de código que realiza una modificación en las reglas de reescritura de URL en un sitio web. La modificación está destinada a corregir el valor de la directiva «RewriteBase» para trabajar correctamente con el plugin WPML (WordPress Multilingual Plugin), que se utiliza para crear sitios web multilingües en WordPress.

Ajuste de las reglas de reescritura de URL en WPML para una integración perfecta, paso a paso

Explicación del código.

1. Se define una función llamada tms_fix_rewritebase utilizando la función function_exists para asegurarse de que no haya otra función con el mismo nombre definida previamente. Si ya existe, este código no se ejecutará. Además se agrega la función mediante add_filter al hook mod_rewrite_rules.

if ( ! function_exists( 'tms_fix_rewritebase' ) ) :
    add_filter( 'mod_rewrite_rules', 'tms_fix_rewritebase' );
    function tms_fix_rewritebase( $rules ) {
    }
endif;

2. Dentro de la función tms_fix_rewritebase, se obtiene la ruta base del sitio utilizando la función parse_url y la función home_url(). La función home_url() devuelve la URL principal del sitio. Si la URL tiene una ruta (por ejemplo, «https://example.com/path/»), se almacena esa ruta en la variable $home_root utilizando la función trailingslashit para asegurarse de que termine con una barra diagonal.

$home_root = parse_url( home_url() );
if ( isset( $home_root['path'] ) ) :
    $home_root = trailingslashit( $home_root['path'] );
else :
    $home_root = '/';
endif;

3. Se obtiene la ruta base de WPML utilizando la función parse_url y la función get_option('home'). La función get_option('home') devuelve la URL principal del sitio en la configuración de WordPress. Si la URL tiene una ruta, se almacena en la variable $wpml_root de manera similar a como se hizo anteriormente.

$wpml_root = parse_url( get_option( 'home' ) );
if ( isset( $wpml_root['path'] ) ) :
    $wpml_root = trailingslashit( $wpml_root['path'] );
else :
    $wpml_root = '/';
endif;

4. Se reemplaza la cadena «RewriteBase $home_root» en las reglas de reescritura por «RewriteBase $wpml_root» utilizando la función str_replace. Esto asegura que la directiva «RewriteBase» apunte correctamente a la ruta base de WPML en lugar de la ruta base del sitio principal.

$rules = str_replace( 'RewriteBase $home_root', 'RewriteBase $wpml_root', $rules );

5. De manera similar, se reemplaza la cadena «RewriteRule . $home_root» por «RewriteRule . $wpml_root» utilizando la función str_replace. Esto asegura que las reglas de reescritura de las URL también utilicen la ruta base de WPML.

$rules = str_replace( 'RewriteRule . $home_root', 'RewriteRule . $wpml_root', $rules );

6. Finalmente, se devuelve el valor modificado de las reglas de reescritura utilizando la variable $rules.

return $rules;

En resumen, este código modifica las reglas de reescritura de URL para asegurarse de que el plugin WPML funcione correctamente al utilizar la ruta base de WPML en lugar de la ruta base del sitio principal. Esto es necesario para garantizar el correcto funcionamiento de la traducción y la gestión de idiomas en un sitio web multilingüe construido con WordPress y WPML.

Mejorando la compatibilidad de WPML con las reglas de reescritura de URL en WordPress

Aquí el codigo completo para copiar.

if ( ! function_exists( 'tms_fix_rewritebase' ) ) :

    add_filter( 'mod_rewrite_rules', 'tms_fix_rewritebase' );

    function tms_fix_rewritebase( $rules ) {

        $home_root = parse_url( home_url() );
        if ( isset( $home_root['path'] ) ) :
            $home_root = trailingslashit( $home_root['path'] );
        else :
            $home_root = '/';
        endif;

        $wpml_root = parse_url( get_option( 'home' ) );
        if ( isset( $wpml_root['path'] ) ) :
            $wpml_root = trailingslashit( $wpml_root['path'] );
        else :
            $wpml_root = '/';
        endif;

        $rules = str_replace( 'RewriteBase $home_root', 'RewriteBase $wpml_root', $rules );
        $rules = str_replace( 'RewriteRule . $home_root', 'RewriteRule . $wpml_root', $rules );

        return $rules;
    }
endif;

Mejorando la navegación entre páginas hijas en WordPress

La función de este código es mostrar la navegación entre páginas, tanto hacia la página anterior como hacia la página siguiente, junto con sus títulos, dentro de una jerarquía de páginas.

La idea es mostrar una navegación entre las páginas hijas de una página principal. Por lo que es necesario tener esa configuración de páginas.

La navegación se mostrará también en la página padre, pudiendo así «empezar a navegar» desde esa misma página.

El codigo trabaja a partir del menu_order de las páginas hijas, excluyendo las páginas con el orden de menú a 0. Por lo que si se quiere no usar esta navegación en un grupo de subpaginas, es tan fácil como dejar el menu_order a cero.

Implementación de la navegación entre páginas hijas en WordPress

Explicación del código.

1. Se obtiene el ID de la página actual utilizando la función get_the_ID() y se inicializan algunas variables para almacenar la información de la página anterior y siguiente.

$current_id = get_the_ID();
$next_id = '';
$next_title = '';
$next_link = '';
$class = '';

2. Se verifica si la página actual tiene un padre utilizando la función wp_get_post_parent_id(). Si tiene un padre, significa que se encuentra dentro de una jerarquía de páginas.

if ( wp_get_post_parent_id( $current_id ) ) :

3. Si la página actual tiene un padre, se obtiene el ID del padre y se obtiene el orden de la página actual utilizando la función get_post_field(). También se calculan los valores de orden para la página anterior y siguiente.

$parent_id = wp_get_post_parent_id( $current_id );
    $current_order = get_post_field( 'menu_order', $current_id );
    $current_order_prev = $current_order - 1;
    $current_order_next = $current_order + 1;

4. Se obtienen todas las páginas hijas del padre utilizando la función get_pages() y se recorre el arreglo de páginas para encontrar la página anterior y siguiente basándose en el orden.

$pages = get_pages( array(
    'child_of' => $parent_id,
    'post_status' => 'publish',
) );

if ( 0 < $current_order_prev ) :
    foreach( $pages as $page ) :

5. Si el valor de $current_order_prev es mayor que 0, significa que hay una página anterior, por lo que se asigna su ID, título y enlace a las variables correspondientes. Si no hay una página anterior, se asigna el ID, título y enlace del padre.

$pages = get_pages( array(
    'child_of' => $parent_id,
    'post_status' => 'publish',
) );

if ( 0 < $current_order_prev ) :

    foreach( $pages as $page ) :
        if ( $page->menu_order == $current_order_prev ) :

            $prev_id = $page->ID;
            $prev_title = $page->post_title;
            $prev_link = get_permalink( $prev_id );

            break;
        endif;
    endforeach;

else :

    $prev_id = $parent_id;
    $prev_title = get_the_title( $prev_id );
    $prev_link  = get_permalink( $prev_id );

endif;

6. Se busca la página siguiente basándose en el orden y se asigna su ID, título y enlace a las variables correspondientes.

foreach( $pages as $page ) :
    if ( $page->menu_order == $current_order_next ) :

        $next_id = $page->ID;
        $next_title = $page->post_title;
        $next_link = get_permalink( $next_id );

        break;
    endif;
endforeach;

7. Si la página actual no tiene un padre, se asigna la clase CSS «only-next» para mostrar solo el enlace a la página siguiente.

else :
$class = ' only-next';

8. Se obtienen todas las páginas hijas de la página actual y se busca la página con orden 1 para asignar su ID, título y enlace a las variables correspondientes.

$pages = get_pages( array(
    'child_of' => $current_id,
    'post_status' => 'publish',
) );

foreach( $pages as $page ) :
    if ( $page->menu_order == 1 ) :

        $next_id    = $page->ID;
        $next_title = $page->post_title;
        $next_link  = get_permalink( $next_id );

        break;
    endif;
endforeach;

endif;

9. Después de obtener toda la información necesaria, se muestra la navegación utilizando la estructura HTML dentro de un elemento <nav></nav>. Se comprueba si existe una página anterior o siguiente utilizando la condición if (!empty($prev_id) || !empty($next_id)). Si existe al menos una de ellas, se muestra la navegación.

<?php if ( ! empty( $prev_id ) || ! empty( $next_id ) ) : ?>
    <nav class="page-navigation<?php echo $class; ?>" role="navigation">

10. Dentro de la navegación, se muestra el enlace a la página anterior si existe, seguido del título de la página anterior y una flecha hacia la izquierda. Luego se muestra el enlace a la página siguiente si existe, seguido de una flecha hacia la derecha y el título de la página siguiente.

if ( ! empty( $prev_id ) ) :
    echo '<a class="prev" href="' . $prev_link . '" title="">';
        echo '<span class="pagination-meta">' . __( 'Read:', 'tms' ) . ' ' . $prev_title . '</span>' . ap_get_svg_icon( array( 'icon' => 'arrow-left' ) );
    echo '</a>';
endif;

if ( ! empty( $next_id ) ) :
    echo '<a class="next" href="' . $next_link . '" title="">';
        echo ap_get_svg_icon( array( 'icon' => 'arrow-right' ) ) . '<span class="pagination-meta">' . __( 'Read:', 'tms' ) . ' ' . $next_title . '</span>';
    echo '</a>';
endif;

Optimizando la experiencia de navegación en jerarquías de páginas en WordPress

El codigo completo para copiar.

<?php
$current_id = get_the_ID();
$next_id    = '';
$next_title = '';
$next_link  = '';
$class      = '';

if ( wp_get_post_parent_id( $current_id ) ) :

    $parent_id          = wp_get_post_parent_id( $current_id );
    $current_order      = get_post_field( 'menu_order', $current_id );
    $current_order_prev = $current_order - 1;
    $current_order_next = $current_order + 1;

    // Prev

    $pages = get_pages( array(
        'child_of'    => $parent_id,
        'post_status' => 'publish',
    ) );

    if ( 0 < $current_order_prev ) :

        foreach( $pages as $page ) :
            if ( $page->menu_order == $current_order_prev ) :

                $prev_id    = $page->ID;
                $prev_title = $page->post_title;
                $prev_link  = get_permalink( $prev_id );

                break;
            endif;
        endforeach;

    else :

        $prev_id    = $parent_id;
        $prev_title = get_the_title( $prev_id );
        $prev_link  = get_permalink( $prev_id );

    endif;

    // Next

    foreach( $pages as $page ) :
        if ( $page->menu_order == $current_order_next ) :

            $next_id    = $page->ID;
            $next_title = $page->post_title;
            $next_link  = get_permalink( $next_id );

            break;
        endif;
    endforeach;

else :

    $class = ' only-next';

    $pages = get_pages( array(
        'child_of'    => $current_id,
        'post_status' => 'publish',
    ) );

    foreach( $pages as $page ) :
        if ( $page->menu_order == 1 ) :

            $next_id    = $page->ID;
            $next_title = $page->post_title;
            $next_link  = get_permalink( $next_id );

            break;
        endif;
    endforeach;

endif;
?>

<?php if ( ! empty( $prev_id ) || ! empty( $next_id ) ) : ?>

    <nav class="page-navigation<?php echo $class; ?>" role="navigation">

    <?php
        if ( ! empty( $prev_id ) ) :
            echo '<a class="prev" href="' . $prev_link . '" title="">';
                echo '<span>←</span>' . '<span class="pagination-meta">' . __( 'Read:', 'tms' ) . ' ' . $prev_title . '</span>';
            echo '</a>';
        endif;

        if ( ! empty( $next_id ) ) :
            echo '<a class="next" href="' . $next_link . '" title="">';
                echo '<span class="pagination-meta">' . __( 'Read:', 'tms' ) . ' ' . $next_title . '</span>' '<span>→</span>';
            echo '</a>';
        endif;
        ?>

    </nav>

<?php endif; ?>

La idea es crear un campo select en Advanced Custom Fields pero generar sus opciones desde el código PHP. De esta forma podemos reutilizar estos mismos valores en otras partes de la web.

El código define una función llamada tms_icons_list_load_field que se utiliza como filtro en Advanced Custom Fields (ACF), un plugin de WordPress para la creación de campos personalizados.

La función tms_icons_list_load_field se ejecuta cuando se carga un campo específico con una clave field_0000000000000 (este es un valor ficticio en el código, en realidad debería ser una clave real proporcionada por ACF). Esta función modifica las opciones de selección del campo y establece el campo como obligatorio.

Dentro de la función, se define un array llamado $field['choices'] que contiene una lista de iconos con sus respectivos nombres traducidos. Cada elemento del array representa una opción para seleccionar un icono y tiene una clave única (como ‘none’, ‘arrow-right’, ‘arrow-left’, etc.) y un valor que es el nombre traducido del icono en el idioma especificado (‘tms’).

Una vez que se han modificado las opciones del campo, la función devuelve el campo modificado usando return $field;.

En resumen, este código PHP modifica las opciones de un campo personalizado en ACF, añadiendo una lista de iconos y estableciendo el campo como obligatorio. Esto permite al usuario seleccionar un icono de la lista cuando se utiliza este campo personalizado en un formulario de WordPress.

<?php
if ( ! function_exists( 'tms_icons_list_load_field' ) ) :

    add_filter( 'acf/load_field/key=field_0000000000000', 'tms_icons_list_load_field' );

    function tms_icons_list_load_field( $field ) {

        $field['required'] = true;

        $field['choices'] = array(
            'none'          => esc_attr__( 'None', 'tms' ),
            'arrow-right'   => esc_attr__( 'Arrow right', 'tms' ),
            'arrow-left'    => esc_attr__( 'Arrow left', 'tms' ),
            'bag'           => esc_attr__( 'Bag', 'tms' ),
            'blog'          => esc_attr__( 'Blog', 'tms' ),
            'check-false'   => esc_attr__( 'Check false', 'tms' ),
            'check-true'    => esc_attr__( 'Check true', 'tms' ),
            'chevron-right' => esc_attr__( 'Chevron right', 'tms' ),
            'chevron-left'  => esc_attr__( 'Chevron left', 'tms' ),
            'close'         => esc_attr__( 'Close', 'tms' ),
            'facebook'      => esc_attr__( 'Facebook', 'tms' ),
            'instagram'     => esc_attr__( 'Instagram', 'tms' ),
            'headphones'    => esc_attr__( 'Headphones', 'tms' ),
            'linkedin'      => esc_attr__( 'Linkedin', 'tms' ),
            'pinterest'     => esc_attr__( 'Pinterest', 'tms' ),
            'search'        => esc_attr__( 'Search', 'tms' ),
            'twitter'       => esc_attr__( 'Twitter', 'tms' ),
            'youtube'       => esc_attr__( 'YouTube', 'tms' ),
            'whatsapp'      => esc_attr__( 'WhatsApp', 'tms' ),
        );

        return $field;
    }
endif;