Posts

Fuentes personalizadas y Dynamic Type en SwiftUI

Arturo Rivas Arias

Utilizar una tipografía propia es una de las formas más visibles de trasladar la identidad de una marca a una aplicación. El problema aparece cuando esa identidad se construye con tamaños rígidos: el diseño funciona en una captura concreta, pero deja de responder a las preferencias que ha configurado el usuario en el sistema.

En SwiftUI no es necesario elegir entre una fuente personalizada y Dynamic Type. Font.custom puede combinar ambas cosas, siempre que indiquemos el tamaño base y el estilo de texto que debe servir como referencia para el escalado.

Qué aporta Dynamic Type

Dynamic Type no consiste simplemente en multiplicar todos los tamaños por el mismo valor. El sistema aplica curvas de escalado diferentes según el estilo semántico del texto. Un título y un pie de foto no crecen necesariamente en la misma proporción, porque tampoco cumplen la misma función dentro de la interfaz.

Por eso SwiftUI ofrece estilos como .largeTitle, .headline, .body, .callout o .caption. Cuando utilizamos la fuente del sistema, basta con escribir:

Text("La ruta de los faros")
    .font(.title)

Text("Una guía por la costa cantábrica")
    .font(.body)

Además de seleccionar la tipografía de San Francisco y un tamaño apropiado, SwiftUI adapta ambos textos a la categoría elegida en los ajustes de accesibilidad. El objetivo al incorporar una familia propia es conservar ese mismo comportamiento.

Añadir las fuentes al proyecto

Antes de escribir código, hay que incorporar los archivos .ttf u .otf al proyecto y comprobar que pertenecen al target correcto. También deben aparecer en la fase Copy Bundle Resources, ya que no basta con que sean visibles en el navegador de Xcode.

En aplicaciones iOS, los archivos se declaran mediante la clave UIAppFonts, mostrada por Xcode como Fonts provided by application. Sus valores son nombres de archivo e incluyen la extensión:

<key>UIAppFonts</key>
<array>
    <string>Literata-Regular.ttf</string>
    <string>Literata-SemiBold.ttf</string>
    <string>Literata-Bold.ttf</string>
</array>

También es necesario comprobar la licencia de la familia tipográfica. Que una fuente pueda descargarse gratuitamente no implica necesariamente que pueda distribuirse dentro de una aplicación comercial.

El nombre del archivo no siempre es el nombre de la fuente

Este es uno de los errores más habituales. UIAppFonts contiene nombres de archivos, pero Font.custom espera el nombre interno de la fuente, normalmente su nombre PostScript. Ambos suelen parecerse, aunque no tienen por qué coincidir.

Durante el desarrollo se pueden inspeccionar las fuentes que el sistema ha registrado:

#if DEBUG
import UIKit

func printRegisteredFonts() {
    for family in UIFont.familyNames.sorted() {
        print("Familia: \(family)")

        for name in UIFont.fontNames(forFamilyName: family).sorted() {
            print("  - \(name)")
        }
    }
}
#endif

Si el nombre pasado a Font.custom no existe, el sistema puede recurrir silenciosamente a una fuente alternativa. Esta pequeña comprobación evita perder tiempo revisando tamaños o modificadores cuando el fallo está realmente en el registro o en el nombre utilizado.

La API correcta para escalar una fuente personalizada

La variante más explícita de Font.custom recibe tres parámetros:

Text("La ruta de los faros")
    .font(
        .custom(
            "Literata-Bold",
            size: 32,
            relativeTo: .title
        )
    )

El valor 32 representa el tamaño base elegido para la fuente, mientras que .title determina la curva con la que se adaptará a Dynamic Type. No significa que el texto deba tener el mismo tamaño que la fuente del sistema para .title: cada familia presenta una altura de x, unas proporciones y una legibilidad diferentes. El tamaño base debe decidirse visualmente junto con diseño.

Conviene distinguir las tres variantes disponibles:

  • Font.custom(_:size:relativeTo:) escala respecto al estilo indicado.
  • Font.custom(_:size:) también escala, pero toma .body como referencia.
  • Font.custom(_:fixedSize:) mantiene un tamaño fijo y no responde a Dynamic Type.

La segunda forma puede ser suficiente para texto de cuerpo, pero resulta ambigua al utilizarla en títulos, leyendas o metadatos. Indicar siempre relativeTo hace explícita la intención semántica y evita que toda la jerarquía tipográfica siga por accidente la curva de .body.

fixedSize debe reservarse para casos en los que el texto no tenga una función de lectura, como un glifo decorativo construido con una fuente de iconos. No es una opción adecuada para titulares, botones, formularios o contenido informativo.

Centralizar la tipografía de la aplicación

Repetir nombres PostScript con literales y tamaños por todas las vistas introduce cadenas frágiles y facilita que aparezcan pequeñas inconsistencias. Una solución sencilla consiste en definir las variantes de la familia y los estilos de producto en un único lugar:

import SwiftUI

fileprivate enum EditorialFont: String {
    case regular = "Literata-Regular"
    case semibold = "Literata-SemiBold"
    case bold = "Literata-Bold"
}

enum EditorialTextStyle {
    case masthead
    case articleTitle
    case body
    case metadata

    fileprivate var configuration: (
        face: EditorialFont,
        size: CGFloat,
        relativeTo: Font.TextStyle
    ) {
        switch self {
        case .masthead:
            return (.bold, 38, .largeTitle)
        case .articleTitle:
            return (.semibold, 24, .title2)
        case .body:
            return (.regular, 17, .body)
        case .metadata:
            return (.regular, 13, .caption)
        }
    }
}

extension Font {
    static func editorial(_ style: EditorialTextStyle) -> Font {
        let configuration = style.configuration

        return .custom(
            configuration.face.rawValue,
            size: configuration.size,
            relativeTo: configuration.relativeTo
        )
    }
}

Las vistas dejan de conocer detalles concretos de la familia tipográfica:

struct ArticleHeader: View {
    let title: String
    let readingTime: Int

    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            Text(title)
                .font(.editorial(.articleTitle))

            Text("Lectura de \(readingTime) min")
                .font(.editorial(.metadata))
                .foregroundStyle(.secondary)
        }
    }
}

Este modelo funciona como un pequeño sistema tipográfico. Si diseño modifica el tamaño de los titulares o sustituye una variante de peso, el cambio se realiza una vez y se propaga a toda la aplicación. Además, los nombres quedan comprobados por el compilador salvo en el único punto donde se conectan con el valor PostScript.

Usar las variantes reales de peso

Aplicar .bold() o .fontWeight(.semibold) sobre una fuente personalizada puede producir un resultado distinto según los archivos registrados y las capacidades de la familia que hayamos importado. Cuando el diseño requiere una variante concreta, resulta más predecible seleccionar directamente su nombre PostScript, como Literata-SemiBold.

También evita que una variante se sintetice o que el sistema elija una aproximación no prevista. La familia debería incluir únicamente los archivos necesarios, ya que cada fuente aumenta el tamaño de la aplicación y debe cargarse en memoria.

Escalar también los elementos relacionados con el texto

Una tipografía más grande puede dejar descompensados iconos, avatares, indicadores o separaciones que permanecen fijos. @ScaledMetric permite que una medida numérica siga la curva de un estilo de texto:

struct ReadingBadge: View {
    @ScaledMetric(relativeTo: .caption)
    private var iconSize: CGFloat = 14

    @ScaledMetric(relativeTo: .caption)
    private var horizontalPadding: CGFloat = 8

    let minutes: Int

    var body: some View {
        Label("\(minutes) min", systemImage: "book.pages")
            .font(.editorial(.metadata))
            .imageScale(.small)
            .frame(minHeight: iconSize)
            .padding(.horizontal, horizontalPadding)
            .padding(.vertical, 5)
            .background(.thinMaterial, in: .capsule)
    }
}

No todas las medidas deben escalar. Los márgenes estructurales de una pantalla, por ejemplo, pueden mantenerse constantes. @ScaledMetric es útil cuando la dimensión está directamente relacionada con el texto y debe conservar su proporción visual.

El diseño también debe adaptarse

Hacer crecer la fuente no garantiza por sí solo una interfaz accesible. En las categorías más altas, una fila horizontal puede necesitar convertirse en una composición vertical. SwiftUI permite consultar si el usuario está utilizando un tamaño de accesibilidad:

struct AuthorSummary: View {
    @Environment(\.dynamicTypeSize) private var dynamicTypeSize

    let name: String
    let biography: String

    var body: some View {
        Group {
            if dynamicTypeSize.isAccessibilitySize {
                VStack(alignment: .leading, spacing: 12) {
                    avatar
                    description
                }
            } else {
                HStack(alignment: .top, spacing: 12) {
                    avatar
                    description
                }
            }
        }
    }

    private var avatar: some View {
        Image(systemName: "person.crop.circle.fill")
            .font(.title)
            .foregroundStyle(.secondary)
    }

    private var description: some View {
        VStack(alignment: .leading, spacing: 4) {
            Text(name)
                .font(.editorial(.articleTitle))

            Text(biography)
                .font(.editorial(.body))
        }
    }
}

También conviene evitar alturas fijas, permitir que el texto ocupe varias líneas y comprobar que los controles no quedan recortados. minimumScaleFactor no debería utilizarse como solución general: reducir el texto puede neutralizar precisamente la preferencia de accesibilidad que el usuario ha seleccionado.

Es posible limitar el intervalo mediante .dynamicTypeSize(...), pero hacerlo sobre una pantalla completa suele crear una barrera innecesaria. Si un componente no soporta las categorías grandes, normalmente es mejor replantear su composición antes que impedir el escalado.

Probar toda la escala de tamaños

Una implementación no está terminada cuando se ve bien con el tamaño predeterminado. Xcode permite revisar variantes de Dynamic Type desde el lienzo de previsualización, y también se pueden crear previsualizaciones específicas:

#Preview("Tamaño predeterminado") {
    ArticleHeader(
        title: "Cuadernos de una isla volcánica",
        readingTime: 7
    )
}

#Preview("Accesibilidad 5") {
    ArticleHeader(
        title: "Cuadernos de una isla volcánica",
        readingTime: 7
    )
    .dynamicTypeSize(.accessibility5)
}

Las previsualizaciones aceleran el trabajo, pero la validación final debe realizarse también en un dispositivo o simulador. Hay que comprobar todas las categorías, textos largos, idiomas con palabras más extensas y los ajustes de texto en negrita. Una familia personalizada puede responder correctamente a Dynamic Type y, aun así, resultar poco legible por su contraste, espaciado o diseño de glifos.

Una jerarquía visual sin renunciar a la accesibilidad

La idea central es separar tres decisiones que a menudo se mezclan: la familia define la identidad visual, el tamaño base ajusta esa familia al diseño y el estilo semántico determina cómo debe escalar. Font.custom(_:size:relativeTo:) reúne esas tres piezas sin perder la integración con Dynamic Type.

Centralizar los estilos, utilizar los nombres PostScript correctos, escalar las medidas relacionadas y adaptar la composición en las categorías de accesibilidad permite construir una tipografía propia que siga comportándose como parte del sistema. El resultado conserva el carácter de la aplicación sin convertir la legibilidad en una concesión.