Construir/Actualizar Pantallas y Vistas desde el Sistema de Diseño
Usa esta habilidad para crear o actualizar pantallas, vistas y contenedores de interfaz de usuario de varias secciones en Figma reutilizando el sistema de diseño publicado: componentes, variables y estilos, en lugar de dibujar primitivas con valores fijos. Esto incluye páginas completas, modales, diálogos, drawers, barras laterales, paneles y cualquier vista compuesta con varias secciones. La idea clave: el archivo de Figma probablemente tiene un sistema de diseño publicado con componentes, variables de color/espaciado y estilos de texto/efecto que se corresponden con los componentes y tokens de la interfaz del código. Encuéntralos y úsalos en lugar de dibujar cajas con colores hexadecimales.
OBLIGATORIO: También debes cargar figma-use antes de cualquier llamada a use_figma. Esa habilidad contiene reglas críticas (rangos de color, carga de fuentes, etc.) que se aplican a cada script que escribas.
Siempre pasa skillNames: "figma-generate-design" al llamar a use_figma como parte de esta habilidad. Es un parámetro de registro. No afecta la ejecución.
Límites de la Habilidad
- Usa esta habilidad cuando el resultado sea una vista compuesta de Figma (nueva o actualizada), pantallas de página completa, modales, diálogos, drawers, barras laterales, paneles o cualquier contenedor de varias secciones, construido a partir de instancias de componentes del sistema de diseño.
- Si el usuario quiere crear nuevos componentes reutilizables o variantes, usa figma-use directamente.
- Si el usuario quiere escribir mapeos de Code Connect, cambia a figma-code-connect.
Prerrequisitos
- El servidor MCP de Figma debe estar conectado
- El archivo de Figma de destino debe tener un sistema de diseño publicado con componentes (o acceso a una biblioteca de equipo)
- El usuario debe proporcionar:
- Una URL del archivo de Figma / clave de archivo en la que trabajar
- O contexto sobre qué archivo es el objetivo (el agente puede descubrir páginas)
- Código fuente o descripción de la pantalla/vista a construir/actualizar
Flujo de Trabajo en Paralelo con generate_figma_design (Solo Aplicaciones Web)
Al construir una pantalla desde una aplicación web que se puede renderizar en un navegador, los mejores resultados se obtienen ejecutando ambos enfoques en paralelo:
- En paralelo:
- Comienza a construir la pantalla usando el flujo de trabajo de esta habilidad (use_figma + componentes del sistema de diseño)
- Ejecuta
generate_figma_designpara capturar una captura de pantalla de píxel perfecto de la aplicación web en ejecución
- Una vez que ambos estén completos: Actualiza la salida de use_figma para que coincida con el diseño de píxel perfecto de la captura de
generate_figma_design. La captura proporciona el espaciado, tamaño y tratamiento visual exactos a los que apuntar, mientras que tu salida de use_figma tiene instancias de componentes adecuadas vinculadas al sistema de diseño. Si la captura contiene imágenes, transfiérelas a tu salida de use_figma copiando los valoresimageHashde los rellenos de imagen de la captura (consulta el Paso 5 para más detalles). - Una vez confirmado que se ve bien: Elimina la salida de
generate_figma_design. Solo se usó como referencia visual.
Esto combina lo mejor de ambos: generate_figma_design proporciona precisión de diseño de píxel perfecto, mientras que use_figma proporciona instancias de componentes del sistema de diseño adecuadas que se mantienen vinculadas y actualizables.
Este flujo de trabajo en paralelo es OBLIGATORIO cuando la fuente contiene imágenes. La API de Plugin de use_figma no puede obtener URLs de imágenes externas. Solo puede establecer rellenos de imagen copiando valores imageHash de nodos que ya están en el archivo. generate_figma_design rasteriza todas las imágenes visibles en Figma, proporcionando los hashes que necesitas. Si omites la captura cuando hay imágenes, los marcos de imagen quedarán en blanco.
Para aplicaciones que no son web (iOS, Android, etc.) o al actualizar pantallas existentes, usa el flujo de trabajo estándar a continuación.
Flujo de Trabajo Requerido
Sigue estos pasos en orden. No te saltes pasos.
Puertas duras, atajos prohibidos:
- Prohibido:
search_design_systempara claves de componentes hasta que 2a-i esté completo y 2a-ii se haya intentado o registrado como N/A (por ejemplo, "archivo vacío, sin pantallas existentes").- Prohibido: Cualquier llamada a
use_figmaque mute el lienzo (Paso 3+) hasta que todas las filas del Paso 2 en la lista de verificación a continuación estén completas.
Paso 1: Entender la Entrega
Antes de tocar Figma, comprende lo que estás construyendo:
- Si se construye desde código, lee los archivos fuente relevantes para entender la estructura, las secciones y qué componentes se utilizan.
- Identifica las secciones principales de la vista (por ejemplo, para una página: Encabezado, Hero, Paneles de Contenido, Pie de página; para un modal: Barra de Título, Secciones de Formulario, Barra de Acciones; para una barra lateral: Navegación, Área de Contenido, Acciones de Pie de página).
- Para cada sección, enumera los componentes de la interfaz de usuario involucrados (botones, campos de entrada, tarjetas, pestañas de navegación, acordeones, etc.).
- Verifica si la vista contiene imágenes (por ejemplo,
<img>,<Image>, imágenes de fondo, fotos de productos, avatares, iconos cargados desde URL). Si las contiene y esto es una aplicación web, debes ejecutar el flujo de trabajo en paralelo de captura degenerate_figma_design, comiénzalo inmediatamente junto con el Paso 2 para que la captura se ejecute mientras descubres componentes. Consulta "Flujo de Trabajo en Paralelo con generate_figma_design" arriba.
Paso 2: Recolectar Claves de Componentes, Variables y Estilos
Necesitas tres cosas del sistema de diseño: componentes (botones, tarjetas, etc.), variables (colores, espaciado, radios) y estilos (estilos de texto, estilos de efecto como sombras). No codifiques colores hexadecimales ni valores de píxel cuando existan tokens del sistema de diseño.
2a: Descubrir componentes
2a-i. REQUERIDO: Revisar Code Connect para los componentes necesarios. A partir de la lista de componentes que construiste en el Paso 1, verifica si cada componente tiene un archivo Code Connect en la base de código. Los archivos Code Connect se encuentran junto al código fuente del componente y se nombran según la plataforma:
- TypeScript/JS:
*.figma.ts,*.figma.js - React (basado en parser):
*.figma.tsx - Kotlin/Compose: archivos
.ktque contienen@FigmaConnect - Swift: archivos
.swiftque contienenFigmaConnect
Para cada componente que necesites (por ejemplo, Button, Card, Input), busca su archivo Code Connect, haz glob o grep por nombre de componente (por ejemplo, **/Button.figma.tsx, **/Card.figma.ts). Solo lee archivos que coincidan con componentes que realmente necesitas.
De cada archivo Code Connect coincidente, extrae la URL del componente de Figma. Parsea fileKey y nodeId de la URL (convierte guiones a dos puntos: 123-456 → 123:456). Luego resuelve las claves de los componentes mediante use_figma:
Ejemplo: El archivo Code Connect contiene // url=https://figma.com/design/ABC123/File?node-id=609-35535. Parsea fileKey = ABC123, nodeId = 609:35535. Ejecuta use_figma contra el archivo de biblioteca (fileKey ABC123, no el archivo de destino) para resolver la clave:
const node = await figma.getNodeByIdAsync("609:35535");
const set = node?.parent?.type === "COMPONENT_SET" ? node.parent : node;
return { componentKey: set.key };
Agrupa múltiples búsquedas en una sola llamada. Usa las claves devueltas con importComponentSetByKeyAsync() en el Paso 4.
Marca los componentes resueltos. Si todos los componentes están resueltos, omite 2a-ii y 2a-iii. Si ninguno de los componentes necesitados tiene archivos Code Connect, continúa con 2a-ii.
2a-ii. REQUERIDO si quedan componentes no resueltos: Inspeccionar pantallas existentes. Verifica si el archivo de destino ya contiene pantallas que usen el mismo sistema de diseño. Una sola llamada a use_figma que recorra las instancias de un marco existente te da un mapa de componentes exacto y autoritativo:
// Descubrimiento de solo lectura, omitir contenido invisible dentro de instancias
// (variantes ocultas, etc.) para el findAllWithCriteria cientos de veces más rápido.
figma.skipInvisibleInstanceChildren = true;
const frame = figma.currentPage.findOne(n => n.name === "Existing Screen");
const uniqueSets = new Map();
frame.findAllWithCriteria({ types: ["INSTANCE"] }).forEach(inst => {
const mc = inst.mainComponent;
const cs = mc?.parent?.type === "COMPONENT_SET" ? mc.parent : null;
const key = cs ? cs.key : mc?.key;
const name = cs ? cs.name : mc?.name;
if (key && !uniqueSets.has(key)) {
uniqueSets.set(key, { name, key, isSet: !!cs, sampleVariant: mc.name });
}
});
return [...uniqueSets.values()];
Compara los resultados con tus componentes no resueltos. Marca los que se hayan resuelto nuevamente. Si todos los componentes están resueltos, omite 2a-iii.
2a-iii. ÚLTIMO RECURSO: search_design_system. Solo si quedan componentes sin resolver después de completar tanto 2a-i como 2a-ii.
Antes de buscar, llama a get_libraries para descubrir qué bibliotecas están disponibles para el archivo. Esto devuelve dos listas: bibliotecas ya agregadas al archivo y bibliotecas disponibles para agregar (kits de interfaz de usuario comunitarios y bibliotecas de la organización). Cada entrada incluye un libraryKey que puedes pasar a search_design_system mediante el parámetro includeLibraryKeys para limitar tu búsqueda a bibliotecas específicas en lugar de buscar en todo.
// Paso 1: Descubrir bibliotecas disponibles
get_libraries({ fileKey })
// Devuelve: {
// libraries_added_to_file: [...],
// libraries_available_to_add: [...],
// libraries_available_to_add_next_offset: number | null
// }
// Paso 2: Buscar dentro de una biblioteca específica usando su libraryKey
search_design_system({ query: "button", fileKey, includeLibraryKeys: ["lk-abc123..."] })
Las bibliotecas de la organización en libraries_available_to_add están paginadas (20 por página). Cuando libraries_available_to_add_next_offset no es nulo, hay más bibliotecas de la organización disponibles, llama a get_libraries nuevamente con offset establecido en ese valor para obtener la siguiente página. Los kits de interfaz de usuario comunitarios solo aparecen en la primera página. Si el usuario nombra una biblioteca específica que no ves en la página actual, avanza más páginas antes de rendirte.
Esto es especialmente útil cuando el archivo tiene muchas bibliotecas y deseas resultados específicos (por ejemplo, buscar solo dentro de "iOS 26" o "Material 3" en lugar de obtener coincidencias de cada biblioteca).
Busca de forma amplia: prueba múltiples términos y sinónimos (por ejemplo, "button", "input", "nav", "card", "accordion", "header", "footer", "tag", "avatar", "toggle", "icon", etc.). Usa includeComponents: true para centrarte en componentes.
Incluye las propiedades de los componentes en tu mapa. Necesitas saber qué propiedades TEXT expone cada componente para anulaciones de texto. Crea una instancia temporal, lee sus componentProperties (y las de instancias anidadas), luego elimina la instancia temporal.
Ejemplo de mapa de componentes con información de propiedades:
Component Map:
- Button → key: "abc123", type: COMPONENT_SET
Properties: { "Label#2:0": TEXT, "Has Icon#4:64": BOOLEAN }
- PricingCard → key: "ghi789", type: COMPONENT_SET
Properties: { "Device": VARIANT, "Variant": VARIANT }
Nested "Text Heading" has: { "Text#2104:5": TEXT }
Nested "Button" has: { "Label#2:0": TEXT }
2b: Descubrir variables (colores, espaciado, radios)
Primero inspecciona las pantallas existentes (igual que con los componentes). O usa search_design_system con includeVariables: true.
ADVERTENCIA: Dos métodos diferentes de descubrimiento de variables, no los confundas.
use_figmaconfigma.variables.getLocalVariableCollectionsAsync(): devuelve solo las variables locales definidas en el archivo actual. Si esto devuelve vacío, no significa que no existan variables. Las variables de bibliotecas remotas/publicadas son invisibles para esta API.search_design_systemconincludeVariables: true: busca en todas las bibliotecas enlazadas, incluidas las remotas y publicadas. Esta es la herramienta correcta para descubrir variables del sistema de diseño.Nunca concluyas "no existen variables" basándote únicamente en que
getLocalVariableCollectionsAsync()devuelva vacío. Siempre ejecuta tambiénsearch_design_systemconincludeVariables: truepara verificar variables de biblioteca antes de decidir crear las tuyas.
Estrategia de consulta: search_design_system coincide con los nombres de variables (por ejemplo, "Gray/gray-9", "core/gray/100", "space/400"), no con categorías. Ejecuta múltiples consultas cortas y simples en paralelo en lugar de una consulta compuesta:
- Colores primitivos: "gray", "red", "blue", "green", "white", "brand"
- Colores semánticos: "background", "foreground", "border", "surface", "text"
- Espaciado/dimensiones: "space", "radius", "gap", "padding"
Si las búsquedas iniciales devuelven vacío, prueba fragmentos más cortos o diferentes convenciones de nomenclatura; las bibliotecas varían mucho ("grey" vs "gray", "spacing" vs "space", "color/bg" vs "background").
Inspecciona las variables vinculadas de una pantalla existente para obtener los resultados más autoritativos:
// Descubrimiento de solo lectura, omitir interiores de instancias invisibles para velocidad.
figma.skipInvisibleInstanceChildren = true;
const frame = figma.currentPage.findOne(n => n.name === "Existing Screen");
// boundVariables puede vivir en cualquier nodo de escena, enumerar cada tipo de escena
// solo para alimentar findAllWithCriteria es aproximadamente lo mismo que findAll(() => true)
// y es mucho más ruidoso en la salida del script.
const uniqueIds = new Set(
frame.findAll(() => true).flatMap(n =>
Object.values(n.boundVariables ?? {})
.flatMap(b => Array.isArray(b) ? b : [b])
.map(b => b?.id)
.filter(Boolean)
)
);
const variables = await Promise.all(
[...uniqueIds].map(id => figma.variables.getVariableByIdAsync(id))
);
return variables
.filter(Boolean)
.map(v => ({ name: v.name, id: v.id, key: v.key, type: v.resolvedType, remote: v.remote }));
Para variables de biblioteca (remote = true), impórtalas por clave con figma.variables.importVariableByKeyAsync(key). Para variables locales, usa figma.variables.getVariableByIdAsync(id) directamente.
Consulta variable-patterns.md para patrones de vinculación.
2c: Descubrir estilos (estilos de texto, estilos de efecto)
Busca estilos usando search_design_system con includeStyles: true y términos como "heading", "body", "shadow", "elevation". O inspecciona lo que usa una pantalla existente:
// Descubrimiento de solo lectura, omitir interiores de instancias invisibles para velocidad.
figma.skipInvisibleInstanceChildren = true;
const frame = figma.currentPage.findOne(n => n.name === "Existing Screen");
const styles = { text: new Map(), effect: new Map() };
for (const node of frame.findAll(() => true)) {
// textStyleId está en TEXT y TEXT_PATH; effectStyleId está en la mayoría de tipos
// de formas/contendores de escena. Usa guards `in` para manejar ambos sin una
// lista exhaustiva de tipos.
if ('textStyleId' in node && node.textStyleId) {
const style = await figma.getStyleByIdAsync(node.textStyleId);
if (style && !styles.text.has(style.key)) {
styles.text.set(style.key, { name: style.name, key: style.key, remote: style.remote });
}
}
if ('effectStyleId' in node && node.effectStyleId) {
const style = await figma.getStyleByIdAsync(node.effectStyleId);
if (style && !styles.effect.has(style.key)) {
styles.effect.set(style.key, { name: style.name, key: style.key, remote: style.remote });
}
}
}
return { text: [...styles.text.values()], effect: [...styles.effect.values()] };
Para estilos de biblioteca (remote = true), impórtalos por clave con figma.importStyleByKeyAsync(key). Para estilos locales, usa figma.getStyleByIdAsync(id) directamente.
Lista de Verificación del Paso 2
Antes de pasar al Paso 3, confirma que cada fila esté completa (marcada con ✓) o registrada como N/A con una razón:
| Elemento | Completado | Detalles |
|---|---|---|
| 2a-i Code Connect | ✓/N/A | (número de archivos leídos) |
| 2a-ii Inspección de pantallas | ✓/N/A | (nombre del marco de pantalla existente, razón si N/A) |
| 2a-iii búsqueda_diseño | ✓/N/A | (términos de búsqueda usados, razón si N/A) |
| 2b Variables | ✓/N/A | (nombres de variables encontradas o razón de N/A: "sin sistema de diseño publicado") |
| 2c Estilos | ✓/N/A | (estilos de texto/efecto encontrados o razón de N/A) |
Paso 3: Preparar el Lienzo
Configura la estructura del lienzo antes de construir:
- Crear una página dedicada para esta vista a menos que sea una actualización de una pantalla existente. Ponle un nombre descriptivo (por ejemplo, "Página de Precios" o "Modal de Confirmación de Editar Perfil"). Si es una actualización, navega a la página y marco existentes.
- Eliminar datos de referencia obsoletos de la sesión actual si es necesario (el script anterior puede haber dejado marcos de captura o nodos temporales).
- Crear un marco base con dimensiones adecuadas para el tipo de vista (escritorio, tableta, móvil, modal, etc.) escalado al 100% y nombrado según el nombre de la vista.
Paso 4: Construir la Vista
Construye la vista de forma incremental sección por sección. Para cada sección:
- Importar componentes con
importComponentSetByKeyAsync(key), luego:- Crear instancias usando
.createInstance() - Establecer variantes usando
setProperties()con pares nombre/valor para propiedades VARIANT - Anular texto configurando propiedades TEXT en el objeto de propiedades del componente
- Configurar visibilidad de subinstancias usando propiedades BOOLEAN
- Crear instancias usando
- Aplicar variables a los rellenos, trazos, radios de esquina, etc. Siempre prefiere tokens del sistema de diseño a colores hexadecimales. Por ejemplo,
fillStyleId = "VARIABLE_ID"ofigma.variables.setBoundVariableForPaint(node, paintIndex, variable) - Aplicar estilos a nodos de texto (
textStyleId) y nodos de capa con sombras (effectStyleId). - Posicionar y dimensionar la sección dentro de la vista, usando variables de espaciado cuando estén disponibles.
- Verificar el progreso confirmando que la sección se vea correcta y coincida con las relaciones de diseño de origen.
- Serializar el estado actual después de cada sección exitosa para que puedas continuar si el script falla.
Estrategia de anidamiento de componentes: Los componentes del sistema de diseño pueden contener subcomponentes (por ejemplo, una Tarjeta que contiene un Botón). Al inspeccionar los componentes en el Paso 2, captura el mapa de anidamiento. Cuando configures propiedades en un componente anidado, accede a la instancia anidada a través del árbol de nodos de la instancia padre y modifica sus propiedades directamente.
Paso 4b: Transferir imágenes desde generate_figma_design (Solo Web, cuando hay imágenes)
Cuando ejecutaste el flujo de trabajo en paralelo con generate_figma_design para capturar una vista que contiene imágenes:
- En el resultado de la captura, identifica los nodos que tienen
fillscontype: "IMAGE"y sus valoresimageHash. - En tu salida de
use_figma, identifica los marcos de imagen correspondientes (por ejemplo, marcos de avatar, foto de producto, imagen de fondo). - Copia el
imageHashde la captura a tu marco de imagen configurando los rellenos:frame.fills = [{ type: "IMAGE", imageHash: "<hash de la captura>", scaleMode: "FILL" }]; - Ajusta
scaleModeyimageTransformsegún sea necesario.
Paso 5: Refinar y Verificar
- Verificar la vinculación del sistema de diseño: confirma que las instancias de componentes importados todavía están vinculadas a sus componentes principales.
- Verificar la aplicación de variables y estilos muestreando nodos y reportando si las variables están vinculadas.
- Verificar la precisión del diseño comparando con el código fuente o la captura de
generate_figma_design. - Confirmar nombres consistentes: los nombres de secciones y marcos deben coincidir con la intención del diseño.
- Reportar estado final: imprime un resumen de la estructura de nodos.
Paso 6: Serializar
Después de la construcción final exitosa, escribe la representación de estado actual en un archivo de referencia temporal en el directorio de trabajo para que los scripts posteriores puedan continuar.
Pautas de Ejecución de Scripts use_figma
Construcción por Etapas y Serialización
Los scripts de use_figma deben:
- Comprobar serializaciones anteriores al inicio y pedir al usuario si deben reanudar o reiniciar.
- Construir de forma incremental y reportar progreso a medida que cada sección se completa.
- Serializar estado después de cada sección exitosa usando la API de serialización de scripts proporcionada.
- Manejar errores con gracia: si una sección falla, informa qué salió mal y continúa con la siguiente si es posible, o pide orientación.
Separación de Llamadas a la API
Divide las operaciones de mutación y las de solo lectura en scripts separados.
- Ejecuta primero scripts de descubrimiento de solo lectura (obtener claves de componentes, variables vinculadas, etc.) para recolectar datos de configuración.
- Luego ejecuta scripts de mutación separados que crean marcos, importan componentes, establecen variantes, etc.
- No mezcles búsquedas de solo lectura y mutaciones en una sola llamada a la API a menos que la mutación dependa directamente del resultado de la búsqueda.
Especificación de Visibilidad de la Interfaz de usuario de Figma
Para cada llamada a use_figma, establece:
use_figma(
code: "...",
scriptType: "scriptSetup",
visible: true,
skillNames: ["figma-generate-design"]
)
Escenarios de Ejemplo
Desde Código a Figma: Landing Page desde una Aplicación Web
Configuración: El usuario te da una URL de archivo de Figma y un componente de React en el que están trabajando. El componente renderiza una página completa (Encabezado, Hero, Características, Pie de página) y la página ya existe en Figma pero está desactualizada.
Flujo:
- Lee el archivo fuente de React. Identifica secciones: Encabezado, Hero, Características, Pie de página. Enumera componentes: Button, Card, Heading.
- Verifica si hay imágenes en la representación (por ejemplo, imágenes de fondo del Hero, fotos de productos en la sección Características). Si las hay, inicia
generate_figma_designen paralelo. - Para Button, Card, Heading: busca archivos Code Connect (
**/Button.figma.tsx, etc.). Para los encontrados, extrae URL de Figma, parsea fileKey y nodeId, resuelve claves de componentes. - Para los no resueltos: inspecciona la página existente en busca de instancias. Usa
search_design_systemcomo último recurso. - Descubre variables de color/espaciado inspeccionando el marco existente. Encuentra estilos de encabezado y sombra.
- Crea una página "Página de Precios v2" o navega a la página existente. Limpia marcos de captura antiguos. Crea un marco de 1440x900.
- Construye la sección de Encabezado: importa el componente de navegación, establece variante "Desktop", anula el título de la marca.
- Construye la sección Hero: importa el componente de fondo del sistema de diseño, aplica variables de color, importa el componente Button, establece variante "Primary", anula el texto del botón "Comenzar".
- Continúa con Características, Pie de página. Después de cada sección, serializa el estado.
- Una vez que
generate_figma_designcompleta: transfiere los valoresimageHashde los marcos de imagen de la captura a los marcos de imagen en tu salida de use_figma. - Verifica comparando con la fuente. Reporta el resumen final.
Actualizar un Modal desde Código
Configuración: El usuario quiere actualizar un modal "Editar Perfil" para que coincida con los últimos cambios de código. El modal tiene secciones: Barra de Título, Formulario (Nombre, Correo, Avatar), Barra de Acciones (Cancelar, Guardar).
Flujo:
- Lee el componente Modal. Identifica campos de formulario y botones.
- Verifica imágenes (sí: el avatar es una imagen). Como actualización (no web), usa el flujo estándar: no ejecutes
generate_figma_design. - Encuentra componentes: Input, Button, Avatar (Code Connect o inspección del modal existente).
- Descubre variables del modal existente. Encuentra estilos de texto para etiquetas.
- Ya que estamos actualizando, navega a la página existente, selecciona el marco modal (si es necesario, reemplaza el contenido interior, manteniendo el marco exterior).
- Actualiza cada sección estableciendo nuevas propiedades, anulaciones de texto y variables vinculadas.
- Para el marco de avatar: como no podemos obtener la URL externa desde el plugin, establece un relleno de marcador de posición (por ejemplo, gris) o deja el marco de imagen vacío con una nota.
- Verifica y reporta los cambios.
Construir un Drawer desde cero
Configuración: El usuario describe un drawer lateral que necesita: un encabezado con título y botón de cerrar, una lista de elementos de navegación, un pie con un botón de acción. No se proporciona código, solo una descripción.
Flujo:
- Identifica secciones: Encabezado, Lista de Navegación, Pie. Componentes necesarios: IconButton, NavigationItem, Button.
- Sin imágenes, no se necesita generate_figma_design.
- Descubre componentes mediante Code Connect y búsqueda en el sistema de diseño.
- Descubre tokens de color/espaciado (dimensiones del drawer ~360px de ancho).
- Crea un marco de 360x900. Construye Encabezado con IconButton (variante "Close"), título en texto anidable. Lista de Navegación con instancias repetidas de NavigationItem. Pie con Button (variante "Primary").
- Aplica variables de color de fondo, espaciado interior. Verifica todo.
Notas Adicionales
- Llamadas de solo lectura: Cuando solo necesitas leer datos (descubrir componentes, variables, estilos desde un marco existente), usa
scriptType: "scriptSetup". Solo usascriptType: "scriptMutate"cuando necesites cambiar el documento. - Múltiples instancias de componentes: Cuando construyas vistas con múltiples instancias del mismo componente (por ejemplo, una lista de elementos de navegación), crea la instancia una vez y luego clónala con
.clone()para obtener instancias independientes. - Rendimiento: Para vistas con muchas instancias (más de 50), considera crear una instancia maestra, configurarla completamente y luego clonarla con
.clone()en lugar de importar y crear instancias individuales separadas para cada una.