Tag: Frontend

  • 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.