De Figma al código
Los tokens de código
Los tokens que no existen en Figma: cuáles son, por qué viven en código, dónde se escriben y cómo entran en la misma cadena que los de Figma. Y qué pasa cuando Figma puede guardarlos.
Última revisión:
Algunos tokens de DesignToken101 no están en Figma. Los primitivos de código los viste en el módulo 2; en esta lección tienes la lista completa, sabes dónde se escriben y cómo se generan junto a los de Figma, con el mismo nombre y las mismas comprobaciones.
En esta página
- La lista completa
- Por qué se escriben en DTCG
- Dónde viven
- Los breakpoints, tokens que se usan de dos formas
- Cuando Figma puede guardarlo, se mueve
- Lo que te llevas
La lista completa
| Tokens | Valor | Por qué no está en Figma | Dónde se explica |
|---|---|---|---|
line-height/tight, snug, normal | 1.2, 1.4, 1.5 | Figma lee una variable de interlineado como píxeles, no como multiplicador | Tipografía |
space/negative/100 … 600 | −4 a −24 px | En Figma se aplicarían al gap o al padding, y en CSS ninguno de los dos admite negativos | Espaciado |
duration/200, duration/2000, easing/standard | 200 ms, 2000 ms, cubic-bezier(0.2, 0, 0, 1) | Figma tiene variables Timing y Easing, pero se aplican a Figma Motion, y esta web no diseña animaciones en Figma | Tipos simples |
breakpoint/sm, md, lg, xl, 2xl y breakpoint/desktop | 40 a 96rem; desktop es un alias de lg (64rem) | En Figma, el modo de Layout se elige a mano en cada marco: nada usa un corte | Los modos en código y El tema de Tailwind CSS |
blur/300 | 12 px | Difumina lo que pasa por debajo de la cabecera fija. DesignToken101 no tiene estilos de efecto en su versión 1, así que el desenfoque no se diseña en Figma | Esta lección |
opacity/inactive | 0,4 | Atenúa un resultado desactualizado en Generar escalas, un estado que no se dibuja en Figma | Tipos simples |
Cada fila tiene un motivo distinto, pero la regla es la misma: cada token tiene una sola fuente. Si Figma no puede guardar un token como lo necesita el código, o no lo usa, su fuente es la especificación del sistema, no el archivo de Figma (Una sola fuente de verdad).
Por qué se escriben en DTCG
Un token de código podría escribirse directamente en el CSS, a mano. DesignToken101 no lo hace: lo escribe en un archivo DTCG, junto a la exportación de Figma, y lo genera con la misma herramienta.
Recomendación
Escribe los tokens de código en DTCG, no en el CSS. Así reciben el mismo trato que los de Figma:
- El mismo nombre:
--t101-más la ruta con guiones. - La misma conversión de unidades:
-4pxpasa a-0.25rem. - La misma capa de Tailwind CSS: la clase
mt-negative-100aplicamargin-top: var(--t101-space-negative-100)(El tema de Tailwind CSS). - La misma comprobación: si un valor no coincide con la especificación, la comprobación falla (Comprobar y actualizar).
Cada token lleva además una $description que dice por qué vive en código. Pasa al CSS como comentario: quien lea la variable sabe por qué no la encontrará en Figma.
Dónde viven
Todos están en un archivo, tokens/code-only.tokens.json. El Resolver lo carga en el conjunto base, junto a Primitives y Semantic size, porque sus valores no cambian con el tema ni con el ancho (DTCG no tiene modos).
Un detalle del formato: en este archivo, el tipo se escribe en el grupo y lo heredan sus tokens. Los tres interlineados comparten "$type": "number" en el grupo line-height. El Format Module lo permite: un token sin $type toma el de su grupo más cercano (Format Module: Type).
Los breakpoints, tokens que se usan de dos formas
DesignToken101 tiene seis breakpoints. Cinco son los de Tailwind CSS, con sus nombres: breakpoint/sm a breakpoint/2xl. El sexto, breakpoint/desktop, es el corte entre los modos Mobile y Desktop de Layout, y es un alias de breakpoint/lg. Es el mismo reparto que en el color: el primitivo dice cuánto vale; el semántico, para qué sirve (Las capas).
Se generan como cualquier token: --t101-breakpoint-lg: 64rem y --t101-breakpoint-desktop: var(--t101-breakpoint-lg). Pero donde se necesitan, en la condición de una consulta @media, no se puede escribir var(--t101-breakpoint-desktop).
Lo que dice la fuente: var() no se puede usar en los nombres de propiedad, en los selectores ni en ningún sitio que no sea el valor de una propiedad (MDN: var()). La condición de una @media no es el valor de una propiedad.
Por eso la configuración lee el valor del token y lo escribe tal cual en la consulta: @media (width >= 64rem). Si el token es un alias, como desktop, sigue la referencia hasta el valor. El valor sigue teniendo una sola fuente, el token; lo que cambia es que se copia al generar, no se referencia. Lo mismo pasa en la capa de Tailwind CSS (Los breakpoints).
Cuando Figma puede guardarlo, se mueve
Tres tokens empezaron en código y hoy salen de Figma:
| Token | Por qué empezó en código | Desde |
|---|---|---|
size/sidebar/width | El diseño dibujaba el sidebar a 305 px sin variable | Variable de Semantic size desde el 2026-10-04 |
color/background/overlay | Se añadió al construir el panel móvil, antes de dibujarlo en Figma | Variable de Semantic color desde el 2026-10-04 |
color/background/neutral/translucent | Se añadió al construir la cabecera fija | Variable de Semantic color desde el 2026-10-04 |
Cuando se crearon sus variables en Figma, se quitaron del archivo de código. No se copiaron: un token no puede tener dos fuentes (Los primitivos que viven en código). Al cambiar de fuente, el CSS siguió dando los mismos valores (19rem, #00000080, #ffffffe6 y #050c09e6), y una comprobación lo vigila.
Nota
Con los de movimiento podría pasar lo mismo: Figma tiene variables Timing y Easing (Figma: Overview of variables). No hemos comprobado cómo se exportan en DTCG, así que DesignToken101 los mantiene en código.
tokens/code-only.tokens.json (abreviado)
{
"line-height": {
"$type": "number",
"$description": "Solo código (D01): Figma interpreta una variable en el interlineado como píxeles.",
"tight": { "$value": 1.2, "$description": "Títulos grandes" },
"snug": { "$value": 1.4, "$description": "Interfaz, textos cortos" },
"normal": { "$value": 1.5, "$description": "Texto de lectura" }
},
"blur": {
"300": {
"$type": "dimension",
"$value": { "value": 12, "unit": "px" }
}
},
"breakpoint": {
"$type": "dimension",
"sm": { "$value": { "value": 40, "unit": "rem" } },
"md": { "$value": { "value": 48, "unit": "rem" } },
"lg": { "$value": { "value": 64, "unit": "rem" } },
"xl": { "$value": { "value": 80, "unit": "rem" } },
"2xl": { "$value": { "value": 96, "unit": "rem" } },
"desktop": { "$value": "{breakpoint.lg}" }
}
}Los breakpoints se escriben en rem, la unidad de la consulta. Los tamaños de Figma llegan en px y se convierten al generar; estos no se convierten, porque ya están en rem. desktop no tiene valor propio: {breakpoint.lg} es una referencia, como las de los semánticos.
La configuración de Terrazzo lee los breakpoints del mismo archivo. Una función devuelve el valor de uno, siguiendo la referencia si es un alias, y con ella se escribe la consulta del modo Desktop:
terrazzo.config.mjs (abreviado)
const codeOnly = JSON.parse(fs.readFileSync(new URL('./tokens/code-only.tokens.json', import.meta.url), 'utf8'));
// Valor de un breakpoint, con el alias resuelto: una consulta @media no lee variables CSS.
const breakpoint = (name) => {
const { $value } = codeOnly.breakpoint[name];
return typeof $value === 'string'
? breakpoint($value.slice(1, -1).split('.').pop()) // "{breakpoint.lg}" → lg
: `${$value.value}${$value.unit}`;
};
const DESKTOP = `(width >= ${breakpoint('desktop')})`; // (width >= 64rem)Lo que te llevas
- Los tokens que Figma no guarda como los necesita el código, o no usa, viven en un archivo DTCG escrito a mano.
- Se generan con la misma herramienta que los de Figma: mismo nombre, mismas unidades y mismas comprobaciones.
- Cuando Figma puede guardar uno de ellos, el token se mueve a Figma y sale del archivo de código.