En el artículo sobre tipografía fluida con clamp() calculamos una progresión lineal para que un texto creciese entre dos tamaños conocidos, sin tener que inventarnos qué pasaba en cada resolución intermedia.
Funcionaba bien: una pantalla más ancha, un texto más grande. Pero ¿qué pasa si ese texto vive en una tarjeta que ocupa un tercio de la pantalla? ¿Y si la misma tarjeta aparece después en una columna lateral?
El viewport sigue siendo enorme pero el espacio disponible para nuestro componente puede ser bastante pequeño, y el titular no se ha enterado.
La recta sigue sirviendo
Antes de cambiar nada, conviene separar los papeles de nuestras variables:
--D1y--D2son los tamaños mínimo y máximo que queremos para el texto.--T1y--T2son las dimensiones de referencia en las que debe alcanzar esos tamaños.Tes la dimensión disponible en cada momento.
En el primer artículo, T era el ancho del viewport. Ahora queremos que sea el
del contenedor. El cálculo es el mismo, solo cambia qué estamos midiendo.
D = a × T + b
a = (D2 - D1) / (T2 - T1)
b = D1 - a × T1
No tenemos que convertir --D2 o --T2 a porcentajes. Estas variables siguen definiendo dos
puntos de nuestra recta, lo que cambia es la unidad con la que expresamos la
medida: donde usábamos 100vw, usaremos 100cqw o 100cqi.
Del viewport al contenedor
Las unidades de contenedor nos permiten expresar longitudes relativas a un contenedor de consulta:
1cqwes el 1 % de su ancho físico.1cqies el 1 % de su tamaño en el eje en línea, el eje en el que avanza el texto.
cqies la unidad lógica correspondiente a la unidad fisicacqw. Laihace referencia ainline-sizeyweswidth. Coinciden en escritura horizontal; en escritura vertical, el eje en línea pasa a ser vertical.
En una escritura horizontal, ambas medidas coinciden. En una escritura vertical,
el eje en línea es vertical, así que no representan lo mismo. Para una escala
que debe seguir el espacio de composición del texto, cqi suele expresar mejor
la intención.
Pero necesitamos indicar cuál será ese contenedor:
<article class="card">
<h2 class="card__title">Un titular que conoce su espacio</h2>
<p>El mismo componente puede vivir en lugares muy diferentes.</p>
</article>
.card {
container-type: inline-size;
}
Con inline-size podemos leer el tamaño del eje en línea. Es
suficiente para este ejemplo y evita contener también el tamaño del eje de
bloque, como haría size.
El contenedor debe ser un ancestro del elemento que utiliza la unidad. Declarar
container-typeen el propioh2no hace que sufont-sizese calcule respecto a sí mismo.
Primero, el mismo ejemplo
En el artículo anterior queríamos pasar de 30px a 80px entre 375px y
1440px. Manteniendo esos dos puntos, la expresión queda así:
.card__title {
font-size: clamp(30px, calc(12.394366px + 4.694836cqi), 80px);
}
Ahora el titular mide aproximadamente 30px cuando el contenedor tiene 375px
en el eje en línea, y 80px cuando alcanza 1440px. Los decimales están
redondeados; la recta se calcula con las mismas fracciones del artículo anterior.
La variante con cqw expresa esa progresión respecto al ancho físico:
.card__title {
font-size: clamp(30px, calc(12.394366px + 4.694836cqw), 80px);
}
Con writing-mode: horizontal-tb y el contenedor de este ejemplo, el resultado
es el mismo. Para trabajar en otros modos de escritura hay que comprobar que el
contenedor permite consultar el eje que utiliza la unidad.
Los puntos también deben tener sentido
Cambiar la unidad adapta la referencia, pero no adapta las decisiones de diseño.
Una tarjeta que nunca va a medir 1440px tampoco va a alcanzar ese tamaño máximo.
No es un fallo de clamp() sino que le hemos pedido que llegue demasiado lejos.
Vamos a definir un rango más razonable para nuestro ejemplo:
- Contenedor de
320px: texto de24px. - Contenedor de
800px: texto de48px.
a = (48 - 24) / (800 - 320) = 0.05
b = 24 - 0.05 × 320 = 8
D = 0.05 × T + 8
Trabajando con T y D medidos en píxeles, esta expresión significa que el
tamaño del texto es el 5 % del tamaño del contenedor en el eje en línea, más
8 píxeles.
Como 1cqi representa el 1 % de esa dimensión, el tamaño completo del
contenedor se expresa como 100cqi. Por tanto, tomar el 5 % equivale a:
0.05 × 100cqi = 5cqi
Los 8px son el término independiente de nuestra recta. Al trasladar la
expresión a CSS obtenemos calc(5cqi + 8px), que podemos utilizar dentro de
clamp() para mantener los límites de tamaño:
.card__title {
font-size: clamp(24px, calc(8px + 5cqi), 48px);
}
Por ejemplo, si el contenedor mide 560px en el eje en línea:
1cqi = 560px / 100 = 5.6px
5cqi = 28px
Tamaño del texto = 28px + 8px = 36px
| Tamaño del contenedor | Tamaño del texto |
|---|---|
| 240px | 24px (mínimo) |
| 320px | 24px |
| 560px | 36px |
| 800px | 48px |
| 960px | 48px (máximo) |
Todo esto puede pasar sin cambiar el tamaño de la ventana. Basta con colocar la tarjeta en una columna más estrecha o más ancha.
Una versión configurable
Para no recalcular la expresión cada vez que cambie el diseño podemos conservar las variables del artículo anterior. En este ejemplo los números se escriben sin unidad y representan medidas de diseño en píxeles. Así la pendiente es un número y evitamos dividir longitudes entre sí.
.card {
container-type: inline-size;
}
.card__title {
--D1: 24;
--D2: 48;
--T1: 320;
--T2: 800;
--a: calc((var(--D2) - var(--D1)) / (var(--T2) - var(--T1)));
--b: calc(var(--D1) - var(--a) * var(--T1));
--fluid: calc(var(--a) * 100cqi + var(--b) / 16 * 1rem);
font-size: clamp(calc(var(--D1) / 16 * 1rem), var(--fluid), calc(var(--D2) / 16 * 1rem));
}
Aquí hemos expresado los límites y el término independiente en rem, usando una
referencia de 16px. Con ese tamaño raíz obtenemos los valores de la tabla.
Si el usuario cambia el tamaño de la raíz, esos términos también cambian: ya no
prometemos alcanzar los mismos tamaños en píxeles en los mismos puntos.
Mezclar rem y cqi permite que parte de la fórmula responda a las preferencias
de texto, pero no garantiza por sí solo una tipografía accesible. Hay que probar
el zoom, el aumento de texto, los saltos de línea y que no se recorte contenido.
Y las dos condiciones a seguir para que la fórmula tenga sentido: --T2 debe ser mayor que
--T1 y --D2 no debe ser menor que --D1 para una escala creciente.
Algunas trampas
La primera es pensar que cqi significa «el padre» y no es así. Se utiliza el ancestro más
cercano que permite consultar el eje correspondiente (container-type). Si interponemos otro
contenedor entre la tarjeta y el titular, podemos cambiar la referencia sin
haber tocado la fórmula. Añadir un container-name tampoco fija por sí solo a
qué contenedor se refiere cqi.
La segunda es olvidar declarar el contenedor. Si no hay uno válido, estas unidades toman como referencia el viewport pequeño en el eje correspondiente. El texto puede seguir creciendo y dar la impresión de que todo funciona, aunque estaremos midiendo otra cosa.
La tercera es añadir contención a cualquier elemento sin revisar el layout.
container-type afecta al cálculo de su tamaño así que conviene que el espacio venga
del layout que lo contiene, por ejemplo de una columna de grid. Si el ancho
antes dependía del contenido, hay que comprobar el resultado.
Y una última cosa: no necesitamos escribir una regla @container para usar
cqi. Las unidades nos dan una variación continua. Las consultas con
@container nos sirven cuando además queremos cambiar una composición, por
ejemplo pasar de una tarjeta vertical a una horizontal al superar cierto tamaño.
Conclusión
La progresión lineal no sabe nada de pantallas, sólo relaciona dos medidas, y fuimos nosotros quienes elegimos el viewport como referencia.
Con cqi podemos hacer que el texto responda al espacio que tiene su componente,
y conservar el mismo cálculo. El titular de una tarjeta ya no necesita saber
cuánto mide la ventana: le basta con saber dónde le ha tocado vivir.
