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:

  • --D1 y --D2 son los tamaños mínimo y máximo que queremos para el texto.
  • --T1 y --T2 son las dimensiones de referencia en las que debe alcanzar esos tamaños.
  • T es 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:

  • 1cqw es el 1 % de su ancho físico.
  • 1cqi es el 1 % de su tamaño en el eje en línea, el eje en el que avanza el texto.

cqi es la unidad lógica correspondiente a la unidad fisica cqw. La i hace referencia a inline-size y w es width. 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-type en el propio h2 no hace que su font-size se 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 de 24px.
  • Contenedor de 800px: texto de 48px.
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.

Recursos