Tag: CSS

  • CSS moderno: animar display none con @starting-style y @scope

    CSS moderno: animar display none con @starting-style y @scope

    Te ha pasado. Pones transition: opacity 0.3s en el modal y aparece de golpe. Lo cierras y desaparece de golpe. El DevTools marca la transición como aplicada, y no hace nada.

    Acabas con un setTimeout de 300 ms que oculta el modal cuando "ya debería" haber terminado. Y en el mismo proyecto, otro clásico: una card que no se deja sobrescribir porque alguien escribió .catalog .card .price, y la salida fue un !important.

    Los dos problemas tienen hoy solución nativa en CSS moderno, sin librerías.

    En corto: @starting-style le da al navegador el estado inicial de un elemento que sale de display: none, y transition-behavior: allow-discrete retrasa el cambio a display: none hasta que acaba la salida. @scope limita estilos a un trozo del DOM sin añadir especificidad y, si dos reglas empatan, gana la raíz más cercana. Todo funciona en los navegadores principales en 2026, salvo animar display en Firefox y la propiedad overlay fuera de Chromium.

    Por qué no puedes animar display none con una transición normal

    display es una propiedad discreta: no tiene valores intermedios, así que el navegador la cambia de golpe y arrastra contigo el resto de la transición.

    Hay dos fallos distintos. En la salida, el elemento pasa a display: none en el primer fotograma y la opacidad no llega a verse. En la entrada, el elemento no existía en el árbol de renderizado, así que el navegador no tiene un "antes" desde el que transicionar: pinta directamente el estado final.

    No es un problema nuevo: la pregunta Transitions on the CSS display property lleva abierta en Stack Overflow desde julio de 2010, con más de 2,6 millones de visitas y respuestas que durante años fueron variantes del mismo hack con visibility, max-height o setTimeout.

    La salida se arregla con allow-discrete. La entrada, con @starting-style. Necesitas las dos.

    ¿Qué es @starting-style?

    @starting-style es una regla que define los valores desde los que transiciona un elemento en su primer pintado, por ejemplo cuando pasa de display: none a visible.

    Va acompañada de transition-behavior: allow-discrete, que hace que una propiedad discreta participe en la transición. Según MDN, cuando el destino es display: none el cambio se aplica al 100 % de la duración, y cuando el origen es none se aplica al 0 %. Es justo lo que quieres: visible durante toda la animación en ambos sentidos.

    Este es un <dialog> de confirmación que entra y sale deslizándose, sin una línea de JavaScript para la animación:

    dialog.confirm {
      opacity: 0;
      translate: 0 1rem;
      transition:
        opacity 0.25s ease-out,
        translate 0.25s ease-out,
        display 0.25s allow-discrete,
        overlay 0.25s allow-discrete;
    }
    
    dialog.confirm[open] {
      opacity: 1;
      translate: 0 0;
    }
    
    @starting-style {
      dialog.confirm[open] {
        opacity: 0;
        translate: 0 1rem;
      }
    }
    
    <button type="button" onclick="document.querySelector('.confirm').showModal()">
      Eliminar proyecto
    </button>
    
    <dialog class="confirm">
      <p>¿Seguro? Esta acción no se puede deshacer.</p>
      <form method="dialog">
        <button value="cancel">Cancelar</button>
        <button value="ok">Eliminar</button>
      </form>
    </dialog>
    

    Tres detalles.

    El bloque @starting-style va después de la regla [open]: tienen la misma especificidad y, si lo pones antes, la regla normal lo pisa.

    La propiedad overlay solo importa en elementos del top layer (<dialog> modal, popovers): sin ella, el navegador saca el elemento de la capa superior antes de que termine la salida. MDN avisa de que en un fundido simple apenas se nota.

    Y overlay solo existe en Chromium: en el resto se ignora sin romper nada.

    La animación es la parte fácil del modal: el foco al abrir y cerrar importa más, y lo vimos en cómo gestionar el foco con Angular Aria.

    Si prefieres @keyframes, también puedes meter display dentro. Para un toast que se va:

    .toast.is-leaving {
      animation: toast-out 0.3s ease-in forwards;
    }
    
    @keyframes toast-out {
      to {
        opacity: 0;
        translate: 0 0.5rem;
        display: none;
      }
    }
    

    Antes, ese display se ignoraba. Hoy, en Chrome y Safari, el toast se desvanece y al final deja de ocupar espacio. Con @keyframes no necesitas @starting-style: el primer fotograma ya es el punto de partida.

    Si lo que animas es un cambio de vista entero y no un elemento suelto, la herramienta es otra: lo contamos en el post sobre View Transitions en React 19.3.

    Soporte en navegadores: lo que el CSS moderno ya cubre en 2026

    Todo lo de este post está disponible en Chrome, Edge, Safari y Firefox salvo animar display y la propiedad overlay. Los datos salen de MDN browser-compat-data y del estado Baseline de webstatus.dev, consultados en octubre de 2026:

    Característica Chrome / Edge Firefox Safari Estado Baseline
    @starting-style 117 129 17.5 Newly available (agosto 2024)
    transition-behavior: allow-discrete 117 129 17.4 Newly available (agosto 2024)
    Animar display (keyframes y transición) 117 No (bug 1834877) 18 Limited availability
    overlay 117 No No Limited availability
    @scope 118 146 17.4 (fallo en 26.0–26.3 con <input>/<textarea>) Newly available (24 marzo 2026)

    Chrome soporta @scope desde la 118; webstatus.dev marca la 143 porque cuenta también el tratamiento de & dentro de @scope como :where(:scope). En Chrome, display dentro de @keyframes funciona desde la 116; la 117 es la de las transiciones.

    La lectura práctica: en Firefox la entrada con @starting-style funciona, porque el elemento pasa de none a visible al instante igualmente y la opacidad sí transiciona. La salida no: el elemento desaparece de golpe. Es mejora progresiva pura, nadie se queda sin modal.

    ¿Qué es @scope en CSS?

    @scope es una regla que aplica estilos solo dentro de un subárbol del DOM, delimitado por una raíz y, opcionalmente, por un límite inferior, sin sumar especificidad a los selectores de dentro.

    Esa última parte es la clave. Según MDN, los selectores dentro de @scope se comportan como si llevaran :where(:scope) delante:

    @scope (.product-card) {
      img { aspect-ratio: 4 / 3; object-fit: cover; }   /* 0-0-1 */
      :scope { border: 1px solid #d0d7de; }             /* 0-1-0: estiliza la propia card */
      :scope img { border-radius: 8px; }                /* 0-1-1 */
    }
    

    .product-card img pesa 0-1-1; dentro del scope, img pesa 0-0-1, y cualquier utilidad posterior lo sobrescribe sin pelear. Para tocar la raíz usas :scope, que sí suma como una clase. También admite varias raíces: @scope (.product-card, .cart-line) { … }.

    El donut: parar antes de llegar al contenido ajeno

    La card tiene un bloque de reseñas con avatares. No quieres que el aspect-ratio de las fotos de producto los deforme:

    @scope (.product-card) to (.card-reviews) {
      img { aspect-ratio: 4 / 3; object-fit: cover; }
    }
    

    La raíz es inclusiva (:scope la alcanza) y el límite es exclusivo: .card-reviews y todo lo que contiene queda fuera. Si quieres incluir el propio .card-reviews pero no sus hijos, usa to (.card-reviews > *). Y si el límite solo debe contar cuando es hijo directo de la card, to (:scope > .card-reviews).

    Proximidad: gana la raíz más cercana

    Una tienda con tema oscuro, un bloque promocional claro y, dentro, una card destacada otra vez oscura:

    <main class="theme-dark">
      <section class="promo theme-light">
        <p class="price">29 €</p>
        <article class="product-card theme-dark">
          <p class="price">49 €</p>
        </article>
      </section>
    </main>
    

    Con .theme-light .price y .theme-dark .price (los dos 0-2-0), el segundo precio coincide con ambas reglas y gana la que esté escrita más abajo en la hoja. Si la clara va última, el precio de la card oscura sale con el color del tema claro. Con @scope:

    @scope (.theme-light) {
      .price { color: #0b5394; }
    }
    
    @scope (.theme-dark) {
      .price { color: #7fd1ff; }
    }
    

    Cada precio toma el color de la raíz con menos saltos hacia arriba en el DOM, da igual el orden. Es la misma idea de "gana el tema más cercano" que vimos con light-dark() en imágenes, pero para cualquier propiedad.

    La proximidad va después de la especificidad y antes del orden de aparición. En el issue #6790 de csswg-drafts el grupo de trabajo debatió entre proximidad "fuerte" (por encima de la especificidad) y "débil", y en marzo de 2023 resolvió que "cascade proximity is weaker than specificity". Un :scope .price le gana a un .price aunque su raíz esté más lejos.

    @scope frente a BEM, CSS Modules y Angular: qué aporta el CSS moderno

    @scope no sustituye a todas las técnicas de aislamiento: ocupa el hueco entre el selector descendiente y el Shadow DOM.

    Técnica Especificidad Límite inferior Riesgo o limitación
    Selector descendiente (.card img) Suma la del ancestro No Se filtra a todo lo anidado y obliga a escalar especificidad
    BEM (.card__img) Una clase plana No hace falta Depende de disciplina humana; nombres largos en el HTML
    CSS Modules Una clase con hash No Requiere build; no protege de estilos globales
    Encapsulación emulada de Angular Suma un atributo [_ngcontent-…] por compuesto No Para traspasar a hijos acabas en ::ng-deep, que Angular desaconseja y mantiene solo por compatibilidad
    @scope Cero (salvo :scope) Sí, con to (…) Los estilos globales siguen entrando; soporte completo solo desde 2026
    Shadow DOM Aislamiento real Sí (frontera del shadow root) Aísla demasiado: tematizar exige custom properties o ::part

    Ojo en Angular: @scope no sustituye a ::ng-deep. Con la encapsulación emulada, el compilador también reescribe los selectores de dentro de @scope con el atributo [_ngcontent-…] del componente, así que no llegan al contenido proyectado. Donde sí encaja es en los estilos globales o en componentes con ViewEncapsulation.None: ahí acota hasta dónde baja una regla, con un límite inferior que la encapsulación no te da. Si montas una arquitectura de componentes desde cero, en el curso de Angular Moderno verás dónde termina la encapsulación del framework y empieza tu CSS.

    Cuándo NO usar @scope (y límites de @starting-style)

    No uses estas herramientas como si fueran aislamiento total o animación garantizada en todos los navegadores.

    @scope no es Shadow DOM. Limita hacia dónde salen tus estilos, no lo que entra: un p { color: red } global sigue pintando dentro. Para un widget embebido en webs ajenas, sigues necesitando Shadow DOM.

    El soporte completo es reciente. Firefox lo sacó en la 146 y Safari corrigió en la 26.4 un fallo que impedía aplicar reglas a <input> y <textarea>. En un Firefox anterior a la 146, la regla dentro de @scope no se aplica y punto. Para estilos críticos de layout, ten una versión fuera de @scope.

    La proximidad cuesta depurar. El DevTools te enseña la regla vencedora, pero no siempre deja claro por qué ganó. Con temas anidados en tres niveles, documenta la intención en el CSS.

    @starting-style no sirve para la salida. Solo define el estado de partida al aparecer. La salida depende de allow-discrete y, en Firefox, no existe para display. Si el elemento se elimina del DOM en vez de ocultarse, espera a transitionend antes de quitarlo.

    display en @keyframes no quita el elemento del layout en Firefox. Con forwards, el toast termina transparente pero ocupando su hueco. Escucha animationend y quítalo con JavaScript si el espacio importa.

    Cómo empezar a usar CSS moderno en tu proyecto

    Empieza por las animaciones de salida: son el cambio de CSS moderno con menos riesgo, porque si el navegador no lo soporta el elemento solo se cierra sin transición.

    Busca en tu código los setTimeout que esperan a una animación antes de poner display: none. Cada uno es candidato a allow-discrete más @starting-style, y en Firefox la salida degrada a un cierre instantáneo que nadie reportará como bug.

    Hacemos estas revisiones sobre código real en Dominicode Labs, y en el canal de YouTube de Dominicode cubrimos las novedades de la plataforma web.

    Preguntas frecuentes

    ¿Qué diferencia hay entre @starting-style y transition-behavior: allow-discrete?

    @starting-style define desde qué valores empieza la transición cuando un elemento aparece. allow-discrete permite que propiedades discretas como display formen parte de la transición. Para animar entrada y salida desde display: none necesitas las dos.

    ¿Necesito la propiedad overlay para animar un dialog?

    Solo para elementos en el top layer, como un <dialog> abierto con showModal() o un popover. Retrasa su salida de la capa superior hasta que termina la transición. Hoy solo la soportan Chrome y Edge; en Safari y Firefox se ignora sin errores.

    ¿@scope añade especificidad a los selectores?

    No. La raíz del scope no suma nada: img dentro de @scope (.product-card) pesa 0-0-1. La excepción es :scope, que cuenta como una pseudoclase y suma 0-1-0.

    ¿Puedo usar @scope en producción en 2026?

    Sí, si tu público usa navegadores actualizados: es Baseline desde el 24 de marzo de 2026, con Firefox 146 y Safari 26.4. Si necesitas cubrir versiones anteriores, mantén fuera de @scope las reglas de las que depende el layout.

    ¿Qué gana si dos reglas de @scope tienen la misma especificidad?

    Gana la que tenga la raíz más cercana al elemento en el DOM, sin importar el orden en la hoja. Si la especificidad es distinta, manda la especificidad: la proximidad solo desempata.


    Por Bezael Pérez — Developer senior con más de 15 años de experiencia y fundador de Dominicode.

  • Funciones personalizadas en CSS: @function nativo vs Sass

    Funciones personalizadas en CSS: @function nativo vs Sass

    Antes de que existieran las funciones personalizadas en CSS, todos teníamos un _functions.scss. Abre el de cualquier proyecto con cinco años encima y verás lo mismo: rem(), spacing(), negative(), un fluid-type() que alguien copió de un artículo de 2019. Funcionan. Hasta que alguien pide un modo compacto para un componente.

    Entonces descubres el límite. Esa función de Sass ya se ejecutó. Se ejecutó en tu máquina, durante el build, y escupió un 16px fijo en el CSS final. El navegador nunca supo que ahí había una fórmula. Para el modo compacto toca duplicar clases o volver a escribir calc() a mano.

    Las funciones personalizadas en CSS nativas cambian eso. Ya no compilas la fórmula: la envías al navegador y él la evalúa con los valores reales de la cascada, en cada elemento.

    En corto: Las funciones personalizadas en CSS se definen con la regla nativa @function y, a diferencia de Sass, se evalúan en el navegador leyendo custom properties y media queries del elemento. Funcionan en Chrome y Edge 139+; Firefox no las soporta y Safari solo en Technology Preview, así que hoy van con fallback.

    ¿Qué son las funciones personalizadas en CSS?

    Una función personalizada en CSS es una regla @function con nombre --algo que recibe argumentos y devuelve un valor a través del descriptor result, evaluado por el navegador en el elemento donde se llama.

    Viene del CSS Functions and Mixins Module, un Editor's Draft que firman Miriam Suzanne y Tab Atkins-Bittner (versión del 8 de octubre de 2026). Esta es la mínima expresión:

    @function --negativo(--valor) {
      result: calc(-1 * var(--valor));
    }
    
    .card {
      --gap: 1.5rem;
      margin-top: --negativo(var(--gap)); /* -1.5rem */
    }
    

    Tres detalles de sintaxis que la spec impone. El nombre empieza siempre por --, igual que una custom property. Dentro del cuerpo, los parámetros se leen con var(). Y si la función no declara result, es válida pero devuelve el valor "guaranteed-invalid".

    Sintaxis de @function: tipos, valores por defecto y returns

    La gramática completa admite tipo y valor por defecto en cada parámetro (separado con dos puntos) y un tipo de retorno con returns:

    @function --alpha(--color <color>, --opacidad <number>: 0.5) returns <color> {
      result: oklch(from var(--color) l c h / var(--opacidad));
    }
    
    .badge {
      background: --alpha(var(--brand));       /* 50 % de opacidad */
      border-color: --alpha(var(--brand), 0.8); /* 80 % */
    }
    

    Si pasas un argumento que no encaja con el tipo y el parámetro tiene valor por defecto, MDN documenta que se ignora el inválido y se usa el defecto. Para aceptar varios tipos se usa type(): --x type(<number> | <percentage>).

    El cuerpo también admite variables locales. Son custom properties que solo existen dentro de la función. Así queda la conversión de px a rem sin repetir el 16 por todo el código:

    @function --rem(--px <number>) returns <length> {
      --base: 16;
      result: calc(var(--px) / var(--base) * 1rem);
    }
    
    h1 { font-size: --rem(32); } /* 2rem */
    

    Lo que Sass no puede hacer: leer la cascada en runtime

    Una función personalizada en CSS puede leer custom properties definidas en el sitio de la llamada, sin recibirlas como argumento. La spec lo dice de forma explícita en su sección 2.3, con un ejemplo donde la función usa un --z que solo existe en el div que la invoca.

    Eso te permite escribir esto:

    @function --espacio(--n <number>) returns <length> {
      result: calc(var(--n) * var(--unidad, 0.25rem));
    }
    
    .card { padding: --espacio(4); }      /* 1rem */
    .card.compacta { --unidad: 0.2rem; }  /* 0.8rem, misma regla */
    

    La misma llamada devuelve valores distintos según el contexto del elemento. En Sass, spacing(4) se resolvió en el build y no hay forma de que reaccione a una clase añadida en runtime.

    Pruébalo aquí mismo

    Esta demo usa la función --espacio() de arriba, en vivo y sin JavaScript. Abre "Modo compacto": cambia solo --unidad en el contenedor y las tres tarjetas recalculan su padding y su gap con la misma llamada.

    ✅ Tu navegador soporta @function: la demo funciona en vivo.

    ⚠️ Tu navegador no soporta @function: ves el fallback de padding: 1rem y el modo compacto no cambia nada.

    Modo compacto (–unidad: 0.125rem)

    Mismo CSS, misma llamada –espacio(4). Solo ha cambiado una custom property en el contenedor.

    padding: –espacio(4)
    padding: –espacio(4)
    padding: –espacio(4)

    ¿Quieres tocarlo tú? Abre DevTools, inspecciona una tarjeta y cambia --unidad en .dc-fn-cards. El panel Computed te enseña el padding ya resuelto.

    El cuerpo admite además reglas condicionales como @media. La spec incluye un ejemplo en el que un @media anidado sobrescribe una variable local:

    @function --espacio-responsive(--n <number>) returns <length> {
      --base: 0.25rem;
      result: calc(var(--n) * var(--base));
    
      @media (width >= 1024px) {
        --base: 0.3rem;
      }
    }
    

    Y la escala tipográfica fluida, el clásico clamp() que todo el mundo copia y pega, queda encapsulada en una línea por uso:

    @function --fluido(--min <number>, --max <number>) returns <length> {
      --vw-min: 360;
      --vw-max: 1280;
      --pendiente: calc((var(--max) - var(--min)) / (var(--vw-max) - var(--vw-min)));
      result: clamp(
        calc(var(--min) * 1px),
        calc(var(--min) * 1px + (100vw - var(--vw-min) * 1px) * var(--pendiente)),
        calc(var(--max) * 1px)
      );
    }
    
    h1 { font-size: --fluido(28, 48); }
    h2 { font-size: --fluido(22, 34); }
    

    También puedes usar if() (en Chrome desde la 137) dentro de result. La guía de MDN reescribe un ejemplo con @media como result: if(media(width < 700px): var(--narrow) ; else: var(--wide));. Si ya usas light-dark(), el post sobre light-dark() con imágenes es un buen complemento: el blog de Chrome enseña precisamente una función --light-dark() que hace lo mismo con cualquier valor, no solo con colores.

    Si trabajas con Angular, esto encaja muy bien con los estilos encapsulados por componente. Defines las funciones una vez en los estilos globales y cada componente ajusta sus custom properties. Es el mismo enfoque de tokens que usamos en el curso de Angular Moderno, ahora sin depender del preprocesador.

    Sass @function vs CSS @function: comparativa

    Si vienes de Sass y quieres repasar qué te aporta el preprocesador, aquí tienes las diferencias entre CSS y SCSS. Esta tabla compara solo las funciones:

    Criterio Sass @function CSS @function
    Cuándo se evalúa Una vez, en el build En el navegador, por elemento, con la cascada
    Lee custom properties del contexto No: solo ve valores de compilación Sí, las del sitio de la llamada
    Reacciona a @media o al cambio de una variable No Sí: @media en el cuerpo, if() en result
    Control de flujo @if, @each, @for, @while, recursión Solo condicionales; las llamadas cíclicas devuelven guaranteed-invalid
    Dónde se puede usar En cualquier parte del .scss Solo donde se permite var() (no en selectores ni en condiciones de media query)
    Soporte Todos los navegadores (sale CSS plano) Chrome/Edge 139+, Opera 123+; Safari solo TP; Firefox no
    Limitación / riesgo El valor queda congelado; no hay temas ni densidades en runtime sin duplicar CSS Un error de tipo no avisa: la propiedad queda inválida en computed-value time y vuelve a su valor inicial o heredado

    Los datos de soporte son de caniuse a 13 de octubre de 2026, que da un 70,46 % de uso global. Safari añadió @function en Safari Technology Preview 249 (29 de julio de 2026), pero ninguna versión estable lo incluye todavía.

    Cómo se discutió: del @return al descriptor result

    La propuesta pública es el issue #9350 del CSSWG, que abrió Miriam Suzanne el 13 de septiembre de 2023 con el título "Proposal: Custom CSS Functions & Mixins". La primera versión devolvía valores con una regla @return, igual que Sass. La spec actual usa el descriptor result.

    El hilo también discutió si las funciones debían ver las variables del elemento. Tab Atkins propuso en febrero de 2024 un modelo léxico: la función solo vería sus argumentos y las custom properties que declarase en una lista using (--var1, --var2) (comentario). Roman Komarov se opuso: con sistemas de tokens, declarar decenas de variables por función las haría difíciles de mantener (comentario). La spec actual le da la razón a Komarov: las custom properties del sitio de la llamada están disponibles de forma implícita. El issue se cerró el 9 de julio de 2026 con la etiqueta "Accepted by CSSWG Resolution".

    Chrome quería sacarla antes. Adam Argyle explicó en el blog de Chrome por qué retrasaron @function de Chrome 136 a 139: los revisores del Intent to Ship pidieron más tiempo de experimentación tras cambios importantes en la spec. Chrome 139 salió a estable el 5 de agosto de 2025.

    Fallback de las funciones personalizadas en CSS sin soporte

    El fallback más robusto para funciones personalizadas en CSS es la cascada de toda la vida: declara dos veces la propiedad.

    .card {
      padding: 1rem;            /* Firefox, Safari estable */
      padding: --espacio(4);    /* Chrome/Edge 139+ */
    }
    

    Un navegador que no entiende --espacio() descarta la segunda declaración al parsear y se queda con la primera. MDN propone una variante para detectar soporte: una función sin parámetros --supports() que devuelve none y se usa en display.

    ¿Y @supports at-rule(@function)? La función at-rule() existe en CSS Conditional 5 y, según Bramus, está disponible en Chromium 148 y Firefox 157, así que ahí la condición debería dar verdadero. Pero Chrome 139 a 147 soporta @function y no at-rule(). En esas versiones la condición da falso y se aplica el fallback. No rompe nada, pero desaprovecha soporte real.

    @supports at-rule(@function) {
      .card { padding: --espacio(4); }
    }
    

    Mi recomendación: doble declaración para valores sueltos y @supports at-rule() solo cuando necesites aislar un bloque entero.

    Cuándo NO usar @function

    Si tu tráfico depende de Safari o Firefox y no puedes mantener dos versiones. Sin soporte estable en los dos, cada función necesita su fallback. Si el fallback acaba siendo el mismo calc() que querías evitar, de momento la función no te ahorra nada.

    Si necesitas bucles o generar CSS. @function devuelve un valor, no reglas. Generar 12 clases de grid con @for, iterar un mapa de colores o crear utilidades sigue siendo trabajo de Sass. Los mixins (@mixin, @apply) están en la spec, pero MDN confirma que ningún navegador los soporta.

    Si quieres usarla en una media query o en un selector. La spec solo la admite donde se puede usar var(), así que @media (width > --bp()) no funciona.

    Si tu equipo depende de los errores de compilación. Sass avisa si llamas mal a una función. CSS no: un argumento de tipo incorrecto sin valor por defecto, o un result que no encaja con returns, deja la propiedad inválida en computed-value time. En ese caso no se aplica la declaración anterior, sino el valor inicial o heredado, y el error pasa en silencio. Ojo con esto en la doble declaración: el fallback solo protege a los navegadores sin soporte.

    Cómo migrar funciones de Sass a funciones personalizadas en CSS

    Elige una sola función de tu _functions.scss que dependa del contexto (espaciado por densidad, opacidad de marca, escala fluida) y reescríbela como @function con su fallback. No migres el archivo entero. Mide en DevTools de Chrome cómo resuelve el valor y deja Sass para lo que genera CSS.

    Si quieres ver más CSS moderno aplicado a proyectos reales, lo explico en vídeo en YouTube Dominicode, y en Dominicode Labs compartimos los patrones de producción y los revisamos en comunidad.

    Preguntas frecuentes

    ¿Qué navegadores soportan @function en CSS en octubre de 2026?

    Chrome y Edge desde la versión 139 y Opera desde la 123, según caniuse. Safari lo añadió en Technology Preview 249 pero no en estable, y Firefox no lo soporta. MDN lo marca como "Limited availability" y no Baseline.

    ¿Las funciones personalizadas en CSS sustituyen a Sass?

    No del todo. Sustituyen las funciones que calculan valores, y lo hacen mejor porque reaccionan en runtime. Sass sigue siendo necesario para bucles, mapas, generación de clases y mixins, porque @mixin y @apply todavía no están en ningún navegador.

    ¿Puede una @function leer custom properties que no le paso como argumento?

    Sí. La spec permite leer las custom properties definidas en el elemento donde se llama la función. Por eso la misma llamada puede devolver valores distintos en un componente normal y en uno compacto.

    ¿Qué pasa si una @function devuelve un valor del tipo incorrecto?

    Si result no encaja con el tipo de returns, la función devuelve un valor inválido y la propiedad se vuelve inválida en computed-value time: toma su valor inicial o heredado, no la declaración anterior. Lo mismo pasa si un argumento no encaja con su tipo y el parámetro no tiene valor por defecto; si lo tiene, se usa el defecto. No hay error en consola, así que revisa el valor computado en DevTools.

    ¿Funciona @supports at-rule(@function) para detectar soporte?

    Sí en Chromium 148+ y Firefox 157+, pero da falso en Chrome 139 a 147, que sí soportan @function. Es seguro porque aplica el fallback, aunque conservador. Para valores sueltos, la doble declaración cubre más navegadores.


    Por Bezael Pérez — Developer senior con más de 15 años de experiencia y fundador de Dominicode.

  • Shopify compra Tailwind: no falló el framework, falló el embudo

    Shopify compra Tailwind: no falló el framework, falló el embudo

    El 18 de noviembre de 2025, un contribuidor abrió un pull request en el repositorio de la documentación de Tailwind. La propuesta era razonable: un endpoint llms.txt que sirviera toda la doc en un único archivo de texto, optimizado para que lo consumieran los modelos de lenguaje.

    El PR se quedó parado siete semanas. A principios de enero alguien preguntó en el hilo por qué no avanzaba. Adam Wathan lo cerró el 6 de enero de 2026, y al día siguiente contestó con algo que no era la respuesta a un PR:

    "75% of the people on our engineering team lost their jobs here yesterday because of the brutal impact AI has had on our business."

    "El 75 % de la gente de nuestro equipo de ingeniería perdió su trabajo ayer por el impacto brutal que la IA ha tenido en nuestro negocio."

    Eran cuatro ingenieros. Quedó uno.

    Ocho meses después llegó el desenlace: el 9 de septiembre de 2026, Shopify compra Tailwind Labs. Ni Shopify ni Tailwind Labs han revelado el importe.

    La lectura fácil es "gran salida para un proyecto querido". La útil es otra: aquí no falló el framework. Falló el embudo por el que ese framework se pagaba.


    Qué dice el anuncio de la compra de Tailwind por Shopify

    El anuncio, firmado por Adam Wathan el 9 de septiembre de 2026, se apoya en una promesa. Wathan la escribe sin ambigüedad: "Nothing changes with Tailwind CSS or any of our other open-source projects". Y refuerza: "Everything will always be MIT-licensed". El equipo sigue liderando y manteniendo los proyectos open source, ahora con el respaldo de Shopify.

    Con el negocio es más seco: "On the commercial side, we'll no longer be trying to grow the business around Tailwind". Los clientes actuales de Tailwind Plus y de ui.sh conservan su acceso. Lo que sí cierra son las altas nuevas: "we're closing sign ups for new customers to focus on Tailwind CSS at Shopify".

    La razón declarada es de alineación estratégica: Wathan siempre quiso que el framework se desarrollara al servicio de un producto real, y Shopify fue adoptante temprano —lo usa internamente y con sus merchants.

    Todo eso es cierto. Y no menciona despidos ni caída de ingresos, porque un anuncio de adquisición no es donde se cuenta eso.

    Pero sin esa parte, la historia no se entiende.


    El dato que no cuadra: 69,9 millones de descargas y los ingresos cayendo

    La contradicción es esta: en septiembre de 2026 Tailwind CSS se descarga más que nunca mientras los ingresos de la empresa que lo mantiene caen casi un 80 %.

    Tailwind es un framework de CSS basado en clases de utilidad: compones el estilo en el propio marcado en vez de escribir hojas aparte. Lo expliqué a fondo en qué es Tailwind CSS, y desde entonces se ha comido buena parte del front-end moderno.

    Eso no es entusiasmo. Es medible.

    La semana del 3 al 9 de septiembre de 2026, el paquete tailwindcss registró 69,9 millones de descargas semanales en npm. Para situar la escala: React tuvo 95,7 millones esa misma semana.

    Ponlo al lado del resto de señales.

    Señal Dirección
    Descargas semanales de tailwindcss 69,9 M (3-9 de septiembre de 2026)
    Tráfico a la documentación −40 % desde principios de 2023
    Ingresos casi −80 %
    Equipo de ingeniería −75 % (enero de 2026)

    Descargas: API de npm — 69.920.618 en la semana del 3 al 9 de septiembre de 2026. Tráfico e ingresos: cifras que dio el propio Wathan en el hilo del PR #2388 el 6 y el 7 de enero de 2026. El anuncio de la adquisición no menciona ninguna de las dos.

    Lee la tabla otra vez. La adopción sube. El tráfico y el dinero se desploman.

    Esa contradicción no es una curiosidad. Es el post entero.


    El embudo que rompió la IA: la documentación era el canal de adquisición

    El embudo que se rompió es el de la documentación: durante más de una década, una empresa de herramientas para developers regalaba el open source y monetizaba las visitas que su doc traía desde Google. Funcionaba tan bien que dejamos de mirarlo.

    Regalas el open source. La documentación posiciona en Google porque es contenido técnico específico y con una intención de búsqueda altísima. El developer aterriza a resolver un problema concreto y una fracción descubre por el camino que además vendes algo.

    La documentación no era un centro de coste. Era el canal de adquisición, y durante años el más barato de todos: gratis, evergreen y perfectamente cualificado.

    Ese embudo se rompió. Despacio en el tráfico, de golpe en el dinero.

    Cada vez menos gente aterriza en tailwindcss.com para buscar cómo se hace un grid. Se lo pregunta a Claude, o lo escribe Cursor mientras mira otra cosa. La respuesta llega, es correcta, y nadie visitó la web. La doc se consume más que nunca, pero a través de un intermediario que no monetiza para ti.

    Tailwind no perdió usuarios. Perdió visitas.

    Y su negocio cobraba por visitas.


    La IA no mató a Tailwind sola: shadcn y el encaje del producto de pago

    Cuidado con la narrativa cómoda: "la IA mató a Tailwind" es demasiado limpio para ser verdad.

    En el hilo de Hacker News que siguió a los despidos —1.457 puntos y 840 comentarios— varios clientes de pago decían lo mismo: los componentes de Tailwind Plus les resultaban complicados y demasiado opinados, y shadcn —gratis— les encajaba mejor. Eso no lo provocó ningún modelo de lenguaje. Es competencia normal, de la que ya existía antes de ChatGPT.

    El producto de pago tenía un problema de encaje. Lo que hizo la IA fue quitarle el colchón.

    Con un canal sano, un producto que pierde encaje te da años para corregir el rumbo. Si el canal lleva tres años cayendo hasta perder un 40 %, no te quedan años: te quedan trimestres. Y con los ingresos cayendo casi un 80 %, la decisión ya no es qué construir, sino a quién llamar.

    Y que quede claro: la adquisición no es el fracaso de esta historia, es probablemente el mejor final posible. Un paquete con 69,9 millones de descargas semanales ahora lo paga una empresa con caja, con licencia MIT y el equipo original al mando.

    El fracaso, si acaso, es de un modelo. No de Wathan.


    Por qué te importa aunque no vendas componentes

    Es probable que tengas un producto propio o quieras tenerlo. Un SaaS, un curso, una plantilla, una librería con versión Pro. Yo tengo varios.

    Hazte una pregunta y respóndela con datos, no con intuición:

    ¿Cómo se entera un desconocido de que tu producto existe?

    Si la respuesta es "busca en Google, aterriza en mi web y ahí descubre que vendo algo", tienes exactamente el embudo de Tailwind. Solo que todavía no lo has medido.

    Ahí está el corolario incómodo: la IA no te va a quitar el trabajo de escribir código, pero puede quitarte el canal por el que vendías el código que escribes.

    Cuando escribí sobre micro-SaaS rentables como developer en solitario, la parte que más preguntas generó fue la de distribución. Con razón: el producto es lo que ya sabemos hacer; el canal es lo que decide si existe o no.

    Tres números que puedes mirar esta semana

    1. Porcentaje de altas que llegan por búsqueda orgánica. Si más de la mitad de tus clientes nuevos entran por ahí, dependes de un canal que se mueve bajo tus pies.
    2. Impresiones contra clics en los últimos 24 meses. Si las impresiones aguantan y los clics bajan, no te has hundido en el ranking: la respuesta se sirve sin ti. Es la señal temprana, y llega mucho antes que la caída de ingresos.
    3. Cuántos compradores tenían relación previa contigo. Email, comunidad, canal, lo que sea. Ese porcentaje es tu independencia real del algoritmo de turno.

    Si el tercero es bajo, no tienes un negocio. Tienes un alquiler de tráfico.


    Qué modelos de negocio aguantan cuando la IA se queda el clic

    Aguantan los modelos de negocio que no dependen del clic, y hay menos de los que parece.

    Distribución directa. Una lista de email, un canal propio, un feed que alguien eligió seguir. Entre tú y una bandeja de entrada hay mucho menos intermediario que entre tú y un resultado de búsqueda. Mi canal de YouTube hace justo eso: nadie llega a un vídeo mío preguntándole a Claude cómo se centra un div.

    Comunidad. Gente que vuelve porque hay alguien al otro lado respondiendo. Un LLM contesta la pregunta que sabes formular; no te dice cuál deberías estar haciéndote. En Dominicode Labs esa es la propuesta entera: gente que vuelve cada semana porque hay alguien al otro lado. No hay algoritmo intermedio que pueda cortarlo.

    Producto que la IA no puede regenerar. Un componente de UI se regenera en veinte segundos. Un backend con estado, datos propietarios, SLA y alguien de guardia, no. Cuanto más cerca esté tu producto de "esto lo escribe un modelo en un prompt", más frágil es tu precio.

    Cobrar por el producto, no por el tráfico que genera. Open source más hosting, soporte o servicio gestionado. Es, por cierto, lo contrario de lo que tenía Tailwind: el framework nunca cobró por sí mismo, cobraba la doc que lo explicaba. Ahora lo financia el producto real de otro.

    Ninguna de las cuatro es rápida. Todas se construyen antes de necesitarlas.


    Si tu único canal es el SEO: qué cambiar ahora

    No lo abandones. Sería la reacción exagerada.

    Cámbiale el trabajo. Tu contenido ya no compite por el clic: compite por ser la fuente que el modelo cita. Escribe para que te citen, estructura para que te parseen, publica tu llms.txt —sí, el mismo que Tailwind no pudo permitirse— y deja de medir el éxito en páginas vistas. Lo desglosé paso a paso en SEO vs GEO para developers: cómo conseguir que las IAs citen tus tutoriales.

    Y asume la parte dura: la conversión ya no ocurre en tu web, ocurre después. Cada visita tiene que dejar algo —un email, una suscripción—, porque puede ser la única vez que esa persona pise tu dominio.

    Hay una ironía aquí: aquel PR proponía exactamente esto, un llms.txt con toda la doc. Wathan dijo que le veía el valor y que quería añadirlo, pero que no podía priorizar algo que le quitaba el único canal por el que llegaban clientes. Tenía razón en el diagnóstico. El problema no era el llms.txt: era que el negocio colgaba entero de las visitas. Eso es lo que hay que mover, y hay que moverlo antes de que te lo muevan.

    Montar ese otro sitio —producto propio, distribución y todo lo que hay entre la idea y el primer cliente— es lo que trabajamos paso a paso en el curso Construye con IA: de la idea al producto con Claude Code.


    Lo único que me llevaría de la compra de Tailwind por Shopify

    Que un framework con 69,9 millones de descargas semanales dejara a su empresa con los ingresos casi un 80 % por debajo significa que el uso y el negocio son cosas distintas, y que llevábamos años confundiéndolas porque el SEO nos hacía el favor de unirlas.

    Abre tu analítica hoy: de tus últimos veinte clientes, cuántos te conocían de antes.

    Ese número es tu modelo de negocio real. Lo demás es tráfico prestado.


    Preguntas frecuentes

    ¿Cuánto pagó Shopify por Tailwind Labs?

    No se ha hecho público. Ni el anuncio publicado por Adam Wathan el 9 de septiembre de 2026 ni Shopify han revelado el importe ni la estructura de la operación.

    ¿Por qué ha comprado Shopify a Tailwind Labs?

    Por alineación estratégica, según el anuncio: Shopify fue adoptante temprano de Tailwind CSS y lo usa internamente y con sus merchants, y Wathan siempre quiso desarrollar el framework al servicio de un producto real. El contexto que el anuncio no menciona es económico: en enero de 2026 Tailwind Labs despidió al 75 % de su equipo de ingeniería y el tráfico a su documentación estaba un 40 % por debajo del de principios de 2023.

    ¿Tailwind CSS sigue siendo gratis y open source tras la compra de Shopify?

    Sí. Wathan lo dice literalmente en el anuncio: "Nothing changes with Tailwind CSS or any of our other open-source projects" y "Everything will always be MIT-licensed". El mismo equipo sigue manteniéndolos, ahora con el respaldo de Shopify. Si usas Tailwind en producción, no tienes nada que tocar.

    ¿Qué pasa con Tailwind Plus y ui.sh si ya soy cliente?

    Los clientes actuales mantienen su acceso. Lo que cambia es que se cierran las altas nuevas: en palabras del anuncio, cierran los registros "to focus on Tailwind CSS at Shopify". El producto de pago deja de crecer para que el equipo se centre en el framework dentro de Shopify.

    ¿Por qué cayeron los ingresos de Tailwind si el framework se usa más que nunca?

    Porque cobraban en un sitio distinto de donde estaba el uso. El dinero llegaba por la documentación: posicionaba en Google, el developer aterrizaba a resolver una duda y una parte descubría que existía un producto de pago. Con los asistentes de IA la respuesta llega sin visitar la web. El tráfico a la doc cayó alrededor de un 40 % desde principios de 2023 y los ingresos casi un 80 %, mientras la adopción seguía subiendo.

    ¿Significa esto que el SEO ya no sirve para vender productos para developers?

    Sirve, pero ha cambiado de función. Antes el contenido técnico traía visitas y las visitas traían clientes. Ahora compite por ser la fuente que citan los modelos, y la conversión ocurre fuera de tu web. La conclusión no es dejar de escribir: es dejar de medir en páginas vistas y hacer que cada visita deje una relación directa.

    ¿Debería dejar de usar Tailwind CSS en mis proyectos?

    No hay razón técnica para hacerlo. Mantiene licencia MIT, lo lleva el mismo equipo y ahora hay detrás una empresa que puede financiarlo. El riesgo de continuidad es menor hoy que en enero.


    Por Bezael Pérez — Developer senior con más de 15 años de experiencia y fundador de Dominicode.

  • Starlight 0.42: menos JavaScript, menú móvil roto en silencio

    Starlight 0.42: menos JavaScript, menú móvil roto en silencio

    El viernes actualicé la documentación de un proyecto interno a Starlight 0.42. npx @astrojs/upgrade, build en verde, Lighthouse un punto mejor. Cerré el portátil.

    El lunes un compañero me pasa una captura desde el móvil. El menú abría perfecto. Pero el botón se quedaba gris. Nuestro color de marca al abrir el menú había desaparecido.

    Nada había fallado. Ese es el problema. El CSS no lanza errores: cuando un selector deja de coincidir con algo, se calla y sigue. El build no te avisa, los tests no lo ven y tú te enteras cuando alguien abre el sitio en un teléfono.

    El anuncio oficial de la release vende una paradoja simpática —menos JavaScript y más JavaScript a la vez— y para los detalles te remite al CHANGELOG. Este post es el CHANGELOG explicado, con el CSS concreto que tienes que cambiar.

    El titular es "menos JavaScript". La letra pequeña es que si tocaste el menú móvil con CSS o JS propio, la 0.42 te lo rompe sin decir nada.


    La paradoja de Starlight 0.42: "un 100 % más de JavaScript"

    El chiste es del propio anuncio y tiene truco. Hay dos JavaScript distintos aquí y el post oficial los mezcla a propósito.

    Uno es el JavaScript que va dentro del paquete de npm. Ese sube: Starlight ha dejado de publicar TypeScript y ahora distribuye JavaScript compilado.

    El otro es el JavaScript que llega al navegador de quien lee tu documentación. Ese baja: el menú móvil ya no necesita JS para funcionar.

    Build-time contra runtime. Son cosas distintas y confundirlas es el error clásico al leer notas de release. Con la 0.42 en la mano, un sitio Starlight medio sigue enviando entre 3 y 13 veces menos JavaScript al usuario final que herramientas comparables: MkDocs, Sphinx, VitePress, Nextra, GitBook o Docusaurus.

    Es la misma lógica que ya movía a Astro con las server islands: decidir con precisión qué se ejecuta en el servidor y qué viaja al cliente, en vez de mandarlo todo y confiar. Astro lleva varias releases insistiendo en lo mismo, desde que server islands y actions se estabilizaron en la 6.2.


    Por qué Starlight publicaba TypeScript y por qué ha parado

    Hay una rareza de los proyectos Astro que mucha gente no conoce: puedes publicar archivos .ts directamente en npm y funcionan cuando alguien los instala. Sin build step. Genial para prototipar rápido, y así se venía publicando Starlight desde el principio.

    El coste aparecía en tu proyecto, no en el suyo.

    Si haces typecheck con tsc, TypeScript revisa cualquier .ts que encuentre importado, incluso dentro de node_modules. Así que acababas comprobando el código fuente de Starlight. Y no con la configuración del paquete, sino con la tuya. En algunos casos el rendimiento de tipos en el editor también se resentía. En una base de código del tamaño de Starlight, esos problemas se acumulan.

    La 0.42 compila sus fuentes y distribuye JavaScript más archivos de declaración (.d.ts). El resultado esperable es un typecheck más rápido en tu máquina — y más aún cuando aterrice el compilador de TypeScript escrito en Go.

    Detalle que conviene tener claro: un .d.ts describe tipos en tiempo de compilación y desaparece en tiempo de ejecución. No valida nada.

    La validación de verdad ya la estás usando aunque no te hayas fijado: el frontmatter de tus páginas lo comprueba Starlight con esquemas de Zod durante el build. Y si tu sitio además tiene formularios o endpoints, ahí hace falta el mismo tipo de esquema pero ejecutándose en runtime. Tipos y validación resuelven problemas distintos, aunque la gente los meta en el mismo saco.


    La Popover API: por qué el menú móvil deja de necesitar tu JavaScript

    Aquí está el cambio de fondo.

    Antes, el menú móvil era una máquina de estados escrita a mano: un custom element <starlight-menu-button> que escuchaba clics, cambiaba aria-expanded en el botón y ponía un atributo en el <body>. Si el JavaScript no llegaba a ejecutarse, no había menú.

    Y hay más razones de las que la gente cree para que el JavaScript no se ejecute. La red se cae a medias. Otro script peta antes y se lleva por delante el resto del bundle. Una extensión del navegador se mete por medio. Alguien lo tiene desactivado. En un sitio de documentación —que muchas veces es la primera vez que alguien te ve— eso es una puerta cerrada.

    La 0.42 delega ese estado en la Popover API del navegador. El menú abre aunque tu JavaScript nunca llegue.

    Menos código propio, más primitiva nativa. Es la dirección correcta.

    Pero ojo con la consecuencia: si el estado ya no vive en un atributo del botón, tu CSS no tiene a qué agarrarse.


    Los 3 breaking changes de Starlight 0.42, en una tabla

    Starlight 0.42 rompe tres cosas y solo tres. Esta es la traducción directa de código viejo a código nuevo:

    Qué desaparece Reemplazo en 0.42 A quién afecta
    <starlight-menu-button> y aria-expanded .sl-menu-button y .sl-menu-button:has(~ :popover-open) Estilos, temas o component overrides que apuntaban al botón del menú móvil
    body[data-mobile-menu-expanded] body:has(sl-sidebar-pane:popover-open) CSS o JS propio que reaccionaba a la apertura del menú
    Opción tagline en astro.config Sin reemplazo: se borra Configs que la declararon (nunca hizo nada)

    Si ninguna de las tres filas aparece en tu código, la actualización es transparente. Si aparece alguna, las tres secciones siguientes son tuyas.


    Breaking change 1: el botón del menú móvil

    El botón ya no va envuelto en el custom element <starlight-menu-button> y ya no usa aria-expanded. Ahora apuntas al botón con la clase .sl-menu-button y lees el estado abierto con la pseudo-clase :popover-open.

    Así estaba tu CSS antes:

    /* Antes: Starlight 0.41 y anteriores */
    starlight-menu-button button {
      border-radius: 999px;
      background: var(--sl-color-gray-6);
    }
    
    starlight-menu-button[aria-expanded="true"] button {
      background: var(--dc-brand);
      color: var(--sl-color-white);
    }
    

    Y así queda en la 0.42:

    /* Después: Starlight 0.42 */
    .sl-menu-button {
      border-radius: 999px;
      background: var(--sl-color-gray-6);
    }
    
    /* El estado abierto lo expone el navegador en el panel, no en el botón.
       Seleccionas el botón que tiene un popover abierto como hermano. */
    .sl-menu-button:has(~ :popover-open) {
      background: var(--dc-brand);
      color: var(--sl-color-white);
    }
    

    Fíjate en lo que ha cambiado de verdad. No es un nombre de clase: es de quién es el estado.

    Antes el estado estaba en el botón, porque lo escribía JavaScript. Ahora está en el panel, porque lo gestiona el navegador. Por eso el selector nuevo tiene que ser relacional: :has() con ~ :popover-open significa "este botón, cuando un hermano posterior suyo está abierto".


    Breaking change 2: adiós a data-mobile-menu-expanded

    El atributo data-mobile-menu-expanded que Starlight añadía al <body> mientras el menú estaba abierto ya no existe. Si lo usabas para ocultar una barra flotante, bloquear el scroll o apagar una animación, ese bloque de CSS ha dejado de aplicarse.

    /* Antes */
    body[data-mobile-menu-expanded] .dc-cta-flotante {
      display: none;
    }
    
    /* Después */
    body:has(sl-sidebar-pane:popover-open) .dc-cta-flotante {
      display: none;
    }
    

    Si además tenías JavaScript propio reaccionando al menú, el cambio te ahorra código. Antes tocaba vigilar un atributo:

    // Antes: espiar el atributo que ponía Starlight
    const boton = document.querySelector('starlight-menu-button button');
    
    new MutationObserver(() => {
      const abierto = boton.getAttribute('aria-expanded') === 'true';
      document.body.classList.toggle('menu-abierto', abierto);
    }).observe(boton, { attributeFilter: ['aria-expanded'] });
    

    Ahora el navegador te lo cuenta él solo con un evento nativo:

    // Después: el panel es el popover y emite un evento toggle
    const panel = document.querySelector('sl-sidebar-pane[popover]');
    
    panel?.addEventListener('toggle', (event) => {
      const abierto = event.newState === 'open';
      document.body.classList.toggle('menu-abierto', abierto);
    });
    

    Un MutationObserver menos en tu sitio. Esa es la parte buena de apoyarse en primitivas del navegador: el código que borras no puede fallar.


    Breaking change 3: la opción tagline ya no existe

    Se elimina de la configuración. Nunca se llegó a usar para nada, así que no hay reemplazo: la borras de tu astro.config y listo. Si no la quitas, la validación de config te lo dirá.


    Requisitos mínimos y navegadores que se caen

    Starlight 0.42 exige Astro v7.2.10 o superior. Si usas @astrojs/markdown-satteri, necesitas 0.4.0 o superior. Si sigues con @astrojs/markdown-remark, 7.3.0 o superior.

    Si tu sitio todavía está en Astro v6, el salto grande no es este release, es el anterior: repasa primero las novedades de Astro v7 y hazlo en un PR aparte. Actualizar dos majors en el mismo commit es la forma más rápida de perder la tarde.

    Y hay una lista de navegadores que dejan de tener soporte oficial:

    Navegador Versión mínima soportada
    Chromium 116 (agosto de 2023)
    Safari 17.0 (septiembre de 2023)
    Firefox 125 (abril de 2024)

    No es un capricho, pero tampoco es el mínimo exacto de la API. Firefox 125 y Safari 17.0 son justo las versiones donde aterrizó la Popover API. En Chromium llegó antes, en la 114, así que ahí Starlight se ha guardado dos versiones de margen. Y en iPhone no hay sorpresa: el Safari de iOS la soporta desde la misma 17.0 que el de escritorio.

    El precio de apoyarse en el navegador es aceptar su calendario. Mira tus analíticas antes de decidir: en un sitio de documentación técnica, ese tráfico suele redondear a cero.


    Lo que mejora sin que hagas nada

    Dos cosas llegan gratis con la actualización.

    Rendimiento. La última versión de Sätteri —el motor de Markdown y MDX de Astro escrito en Rust, que llegó en Astro 6.4 y es el motor por defecto desde Astro 7— les ha permitido optimizar componentes y plugins de Markdown, y reducir el número de dependencias de Starlight. El procesado de datos del sidebar es ahora hasta 1.400 veces más rápido, y eso se nota de verdad en sitios con sidebars grandes o muy anidados.

    Ojo con un detalle que no es opcional. Sätteri no ejecuta plugins de remark ni de rehype: tiene su propio sistema de plugins mdast y hast, y no hay fallback automático.

    Y aquí no eliges tú. Como es el motor por defecto de Astro 7, y la 0.42 exige Astro v7.2.10 o superior, la actualización te lo puede cambiar sola. Si tu pipeline depende de remark o rehype, tienes que quedarte explícitamente en @astrojs/markdown-remark 7.3.0 o superior. Compruébalo antes de lanzar el upgrade, no después.

    Accesibilidad. El menú móvil atrapa el foco mientras está abierto, para que no puedas tabular hacia la página que queda escondida debajo. Detrás está el criterio de éxito WCAG 2.4.11, «Focus Not Obscured (Minimum)»: el elemento con el foco no puede quedar tapado por lo que hay encima. Se agradece en viewports pequeños o con mucho zoom. Llegó en la 0.41.3, así que si vienes de la última 0.41.x ya lo tienes. Si esto lo habías parcheado tú a mano, bórralo: ahora hay dos implementaciones peleándose por el foco.


    Cómo actualizar a Starlight 0.42 paso a paso

    1. Comprueba que estás en Astro v7. Starlight 0.42 exige Astro v7.2.10 o superior. Si vienes de Astro v6, haz ese salto antes y en un PR aparte.

    2. Busca lo que se va a romper. Cuatro grep antes de tocar nada:

      grep -rn "starlight-menu-button" src/
      grep -rn "data-mobile-menu-expanded" src/
      grep -rn "aria-expanded" src/styles/
      grep -rn "tagline" astro.config.*
      

      Cada resultado es una línea que hay que migrar. Si no aparece nada, actualiza tranquilo.

    3. Actualiza. Un solo comando sube Starlight, Astro y el resto de integraciones a la vez:

      npx @astrojs/upgrade
      
    4. Migra el CSS y el JS con la tabla de equivalencias de más arriba: .sl-menu-button, .sl-menu-button:has(~ :popover-open) y body:has(sl-sidebar-pane:popover-open).

    5. Abre el sitio en un móvil de verdad y toca el botón del menú. No en el simulador de Chrome: en un teléfono. Es el único sitio donde estos tres breaking changes se manifiestan.

    Este tipo de migración quirúrgica —buscar patrones muertos, cambiarlos y verificar— es exactamente lo que un agente hace bien si le das el CHANGELOG y los selectores concretos. Es el flujo que enseño en Construye con IA: contexto preciso primero, ejecución después.


    La conclusión que te llevas

    Un release que quita JavaScript casi siempre mueve el estado a otro sitio. Y el CSS que apuntaba al estado viejo no se queja: se apaga. Es el mismo patrón que en los breaking changes de pnpm 12: la nota de release vende el titular y el trabajo real está tres párrafos más abajo.

    Si mantienes un sitio con Starlight, haz hoy los cuatro grep de arriba antes de actualizar. Tardas menos de lo que has tardado en leer este post, y te ahorras la captura de un compañero el lunes por la mañana.

    En Dominicode Labs trabajamos este tipo de migraciones sobre proyectos reales, con el diff delante en vez de con el anuncio de marketing. Y el anuncio original, por si quieres la versión oficial, está en el blog de Astro.


    Preguntas frecuentes

    ¿Cómo actualizo a Starlight 0.42?

    Ejecuta npx @astrojs/upgrade, que sube Starlight, Astro y el resto de integraciones a la vez. Antes de lanzarlo, busca en tu proyecto starlight-menu-button, data-mobile-menu-expanded, aria-expanded en tus estilos y tagline en astro.config: cada coincidencia es una línea que hay que migrar. Necesitas Astro v7.2.10 o superior. Después, abre el sitio en un móvil real y comprueba el botón del menú.

    ¿Starlight 0.42 envía más o menos JavaScript al navegador?

    Menos. El "100 % más de JavaScript" del anuncio se refiere al paquete de npm, que ahora se distribuye compilado a JavaScript en lugar de TypeScript. Lo que llega al navegador de quien lee tu documentación baja, porque el menú móvil se apoya en la Popover API nativa en vez de en código propio. Un sitio Starlight medio sigue enviando entre 3 y 13 veces menos JavaScript al usuario final que MkDocs, Sphinx, VitePress, Nextra, GitBook o Docusaurus.

    ¿Por qué ha dejado de aplicarse mi CSS del menú móvil tras actualizar?

    Porque el botón ya no va envuelto en el custom element <starlight-menu-button> y ya no usa el atributo aria-expanded. Cualquier selector construido sobre esos dos elementos deja de coincidir con nada y el navegador lo ignora en silencio. La migración es apuntar al botón con .sl-menu-button y leer el estado abierto con .sl-menu-button:has(~ :popover-open).

    ¿Por qué el selector nuevo usa :has() en lugar de una clase en el botón?

    Porque el estado ha cambiado de dueño. Antes lo escribía JavaScript en el botón; ahora lo gestiona el navegador en el panel del menú, que es el elemento popover. Para estilar el botón según ese estado necesitas un selector relacional: :has(~ :popover-open) significa "este botón, cuando un hermano posterior suyo está abierto". Para el <body>, el equivalente del antiguo data-mobile-menu-expanded es body:has(sl-sidebar-pane:popover-open).

    ¿Qué versiones mínimas necesito para actualizar a Starlight 0.42?

    Astro v7.2.10 o superior. Si usas @astrojs/markdown-satteri, 0.4.0 o superior. Si usas @astrojs/markdown-remark, 7.3.0 o superior. El comando npx @astrojs/upgrade se encarga de subir Starlight, Astro y el resto de integraciones a la vez.

    ¿Debería preocuparme por los navegadores que pierden soporte?

    Depende de tus analíticas, pero casi nunca. Se cae el soporte oficial de Chromium anterior a la 116 (agosto de 2023), Safari anterior a 17.0 (septiembre de 2023) y Firefox anterior a 125. Son los mínimos que exige la Popover API. En documentación técnica ese tráfico suele ser residual; míralo antes de bloquear la actualización por si acaso.

    ¿Qué hago si tenía JavaScript propio escuchando la apertura del menú?

    Bórralo y escucha el evento nativo. El panel es el popover, así que un panel.addEventListener('toggle', ...) con event.newState === 'open' te da lo mismo que antes conseguías con un MutationObserver sobre aria-expanded, con la mitad de código y sin depender de detalles internos de Starlight.

    ¿Y la opción tagline de la configuración?

    Se ha eliminado y no tiene reemplazo, porque nunca se llegó a usar. Bórrala de tu astro.config al actualizar.


    Por Bezael Pérez — Developer senior con más de 15 años de experiencia y fundador de Dominicode.

  • Implementando light-dark() para imágenes en CSS: guía técnica

    Implementando light-dark() para imágenes en CSS: guía técnica

    light-dark() para imágenes: guía práctica

    Tiempo estimado de lectura: 4 min

    • light-dark() ahora soporta <image>, permitiendo alternar assets (logos, fondos, máscaras) según esquema de color sin media queries.
    • Los dos argumentos de light-dark() deben ser del mismo tipo: ambos <color> o ambos <image>; mezclar tipos invalida la regla.
    • Usa la cascada para fallbacks: declara primero un background estándar y luego light-dark() para motores modernos.
    • Beneficios: cohesión del componente, respuesta local al color-scheme y menor deuda técnica frente a variables globales dispersas.

    Introducción

    Back in 2023, I wrote about the future of CSS color switching using the then-novel light-dark() function. It was a game-changer for colors, allowing us to ditch the repetitive @media (prefers-color-scheme: …) blocks for simple property declarations.

    But there was one glaring limitation: it only works for colors. If you wanted to swap out a background image, a mask, or a logo based on the user’s color scheme, you were stuck doing things the “old” way.

    Well, I have good news. The spec has been updated, and light-dark() is being extended to support images.

    Back in 2023, I wrote about the future of CSS color switching using the then-novel light-dark() function. It was a game-changer for colors, allowing us to ditch the repetitive @media (prefers-color-scheme: …) blocks for simple property declarations.

    Pero había una limitación clara: light-dark() solo aceptaba <color>. Si querías alternar una imagen de fondo, una máscara o un logo según el esquema de color, todavía te tocaba escribir variables globales y media queries dispersas. La buena noticia: la especificación ha avanzado y ahora light-dark() acepta <image>. Esto cambia la arquitectura de temas en CSS y merece una guía práctica con criterio.

    Resumen rápido (lectores con prisa)

    Qué es: Una extensión de light-dark() que acepta <image>, permitiendo elegir assets según esquema de color.

    Cuándo usarlo: Cuando necesites alternar logos, fondos o máscaras sin depender de variables globales o JS.

    Por qué importa: Reduce fragmentación de estilos y permite decisiones locales basadas en color-scheme.

    Cómo funciona: Declara light-dark(url(light.png), url(dark.png)) en la propiedad que espera un <image>; ambos argumentos deben ser <image>.

    Qué cambia — ejemplo y patrón recomendado

    Antes (patrón clásico con variables y media queries)

    :root { --bg-image: url(light-pattern.png); }
    
    @media (prefers-color-scheme: dark) {
      :root { --bg-image: url(dark-pattern.png); }
    }
    
    .element { background-image: var(--bg-image); }

    Ahora (light-dark() para imágenes)

    .element {
      color-scheme: dark; /* override local si hace falta */
      background-image: light-dark(url(light-pattern.png), url(dark-pattern.png));
    }

    Ventajas prácticas

    • Cohesión: la decisión de qué asset usar vive en el mismo selector que lo consume.
    • Respuesta local: respeta color-scheme aplicado al nodo o a sus ancestros.
    • Portabilidad: el componente se mueve sin necesidad de variables globales.

    Restricciones técnicas y por qué importan

    Regla crítica: los dos argumentos de light-dark() deben ser del mismo tipo. Es decir, o dos <color> o dos <image>. No mezcles tipos:

    /* válido */
    color: light-dark(#000, #fff);
    background-image: light-dark(url(light.png), url(dark.png));
    
    /* inválido — el parser lo rechazará */
    background-image: light-dark(url(light.png), #1a1a2e);

    ¿Por qué? El parser de CSS valida la sintaxis frente al tipo que la propiedad espera. background-image espera un <image>. Si uno de los argumentos es un <color>, la declaración crea ambigüedad en el AST y el motor invalida la regla. Esta restricción protege rendimiento y predictibilidad del renderizado.

    Progressive enhancement y fallbacks reales

    Soporte por navegador aún está en despliegue. La estrategia correcta es usar la cascada y un fallback explícito:

    .element {
      /* Fallback básico */
      background-image: url(light-pattern.png);
    
      /* Moderno: sobreescribe si se soporta */
      background-image: light-dark(url(light-pattern.png), url(dark-pattern.png));
    }

    Si necesitas cobertura adicional para navegadores antiguos, combina con @media (prefers-color-scheme: dark) como fallback secundario, pero reserva light-dark() como la fuente de verdad cuando el motor lo soporte.

    Casos de uso donde esto realmente aporta valor

    • Logos adaptativos (SVG/PNG): menos JS, menos duplicación de DOM.
    • Patrones de fondo decorativos que deben cambiar con el tema.
    • mask-image o -webkit-mask-image donde el comportamiento depende del contraste.
    • Sistemas de diseño a escala: reduce la deuda técnica y facilita la revisión de cambios de tema.

    Criterio para equipos

    • Documenta la convención: cuándo usar light-dark(), cuándo preferir variables.
    • Revisa en code reviews la homogeneidad de tipos (no mezclar color/imagen).
    • Añade un test visual de regresión (navegación entre temas) en CI si el producto necesita alta fiabilidad.
    • Implementa el fallback mostrado y degrada con gracia: el objetivo es evitar roturas visuales en navegadores sin soporte.

    Conclusión

    La evolución de light-dark() hacia <image> es un paso práctico hacia interfaces menos dependientes de JS y con menos “bolsas” de estilos dispersos. No es una revolución espectacular, pero sí una mejora arquitectónica que reduce deuda técnica y hace los componentes más robustos y portables. Implementa con criterio, añade fallbacks y actualiza tus patrones de diseño: el cambio trae limpieza, y eso en producción siempre paga.

    FAQ

    ¿Qué es exactamente la extensión de light-dark() para imágenes?

    Es la actualización de la especificación que permite pasar <image> como argumentos a light-dark(), de modo que propiedades que esperan imágenes (por ejemplo, background-image) puedan alternar assets según el esquema de color.

    ¿Puedo mezclar colores e imágenes en la misma llamada a light-dark()?

    No. Los dos argumentos deben ser del mismo tipo. Mezclar un <color> con un <image> es sintácticamente inválido y el parser rechazará la regla.

    ¿Cómo debo implementar fallbacks para navegadores sin soporte?

    Usa la cascada: declara primero un fallback (por ejemplo, background-image: url(light-pattern.png);) y luego sobreescribe con light-dark(). Como fallback secundario puedes mantener @media (prefers-color-scheme: dark) si necesitas más compatibilidad.

    ¿Qué propiedades de CSS aceptan con light-dark()?

    Cualquier propiedad que espere un <image> puede aprovechar la extensión, por ejemplo background-image, mask-image y sus prefijos relevantes como -webkit-mask-image.

    ¿Debo seguir usando variables y media queries?

    Sí, en escenarios donde la compatibilidad es crítica o donde la convención del equipo requiere variables globales. Pero para componentes portables y locales, light-dark() ofrece una alternativa más cohesionada.

    ¿Cómo afecta esto al rendimiento y al parser de CSS?

    La restricción de tipo evita ambigüedades en el AST y ayuda al motor a validar y optimizar reglas. El impacto en rendimiento es mínimo si se usa correctamente; la ventaja es mayor predictibilidad del renderizado.

    ¿Dónde puedo leer la especificación y herramientas de diagnóstico visual?

    La especificación relevante es CSS Color Level 5 (W3C). Para diagnóstico visual en Chrome, referencia Chrome DevTools (sección Memory para diagnóstico visual, no confundir con rendimiento).