Communitygithub.com

ComeOnOliver/skillshub

Proporciona patrones de Tamagui para config v4, optimización del compilador, contexto con estilo y estilos multiplataforma. Debe usarse al trabajar con proyectos Tamagui (tamagui.config.ts, importaciones @tamagui).

¿Qué es skillshub?

Este skill ofrece una guía detallada de patrones avanzados para Tamagui v1.x, yendo más allá de los fundamentos. Se centra en Config v4, optimización del compilador, componentes compuestos y errores comunes. Es útil para desarrolladores que trabajan con proyectos Tamagui, ya que proporciona ejemplos prácticos sobre cómo configurar temas con `createThemes`, usar variantes con operadores spread, crear componentes compuestos con `createStyledContext` y `withStaticProperties`, y envolver componentes con `.styleable()`. También cubre el uso de la prop `accept` para tokens personalizados, el orden de las props y anti-patrones como estilos dinámicos, funciones en línea, importaciones incorrectas y mezcla de StyleSheet. El skill soporta múltiples plataformas (web y nativa) y recomienda el uso de `Adapt` para diálogos y sheets. Incluye referencias rápidas para abreviaturas de estilo, media queries y controladores de animación, así como enlaces para obtener documentación actualizada directamente desde la API de Tamagui.

Compatible con~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/aiskillstore/marketplace/0xbigboss/tamagui-best-practices

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Este skill proporciona patrones para Tamagui v1.x que van más allá de los fundamentos. Se enfoca en Config v4, optimización del compilador, componentes compuestos y errores comunes.

Carga de Contexto Obligatoria

Al trabajar con estos componentes, lee el archivo de patrón correspondiente ANTES de escribir código:

Tipo de ComponenteLectura RequeridaHabilidades Cruzadas
Dialog, Sheet, superposiciones modales@DIALOG_PATTERNS.md
Form, Input, Label, validación@FORM_PATTERNS.mdtypescript-best-practices (zod)
Animaciones, transiciones@ANIMATION_PATTERNS.md
Popover, Tooltip, Select@OVERLAY_PATTERNS.md
Optimización del compilador@COMPILER_PATTERNS.md
Tokens de diseño, temas@DESIGN_SYSTEM.md

Inicio Rápido con Config v4

Usa @tamagui/config/v4 para una configuración simplificada:

// tamagui.config.ts
import { defaultConfig } from '@tamagui/config/v4'
import { createTamagui } from 'tamagui'

export const config = createTamagui(defaultConfig)

type CustomConfig = typeof config

declare module 'tamagui' {
  interface TamaguiCustomConfig extends CustomConfig {}
}

Configuración recomendada para proyectos nuevos (alinea flexBasis con React Native):

export const config = createTamagui({
  ...defaultConfig,
  settings: {
    ...defaultConfig.settings,
    styleCompat: 'react-native',
  },
})

Patrón createThemes

Para temas personalizados, usa createThemes con palette/accent/childrenThemes:

import { createThemes, defaultComponentThemes } from '@tamagui/config/v4'

const generatedThemes = createThemes({
  componentThemes: defaultComponentThemes,
  base: {
    palette: {
      dark: ['#050505', '#151515', /* ...12 colores */ '#fff'],
      light: ['#fff', '#f8f8f8', /* ...12 colores */ '#000'],
    },
    extra: {
      light: { ...Colors.blue, shadowColor: 'rgba(0,0,0,0.04)' },
      dark: { ...Colors.blueDark, shadowColor: 'rgba(0,0,0,0.2)' },
    },
  },
  accent: {
    palette: { dark: lightPalette, light: darkPalette }, // invertido
  },
  childrenThemes: {
    blue: { palette: { dark: Object.values(Colors.blueDark), light: Object.values(Colors.blue) } },
    red: { /* ... */ },
    green: { /* ... */ },
  },
})

Sintaxis de Tokens y Temas

Reglas del Prefijo $

  • Props: Usa el prefijo $ para referencias a tokens: <Text color="$color" fontSize="$4" />
  • Claves de tema: Accede sin $ en definiciones de tema: { color: palette[11] }
  • Acceso a tokens en variantes: Usa el patrón tokens.size[name]

Operadores de Propagación en Variantes

Los operadores especiales de propagación mapean categorías de tokens a valores de variantes:

const Button = styled(View, {
  variants: {
    size: {
      // Mapea tokens de tamaño: $1, $2, $true, etc.
      '...size': (size, { tokens }) => ({
        height: tokens.size[size] ?? size,
        borderRadius: tokens.radius[size] ?? size,
        gap: tokens.space[size]?.val * 0.2,
      }),
    },
    textSize: {
      // Mapea tokens de fontSize
      '...fontSize': (name, { font }) => ({
        fontSize: font?.size[name],
      }),
    },
  } as const,
})

Importante: Usa as const en el objeto de variantes hasta que TypeScript soporte genéricos constantes inferidos.

Componentes Compuestos con createStyledContext

Para APIs compuestas como <Button><Button.Text>Click</Button.Text></Button>:

import {
  SizeTokens,
  View,
  Text,
  createStyledContext,
  styled,
  withStaticProperties,
} from '@tamagui/core'

// 1. Crear contexto con tipos de variantes compartidos
export const ButtonContext = createStyledContext<{ size: SizeTokens }>({
  size: '$medium',
})

// 2. Crear marco con contexto
export const ButtonFrame = styled(View, {
  name: 'Button',
  context: ButtonContext,
  variants: {
    size: {
      '...size': (name, { tokens }) => ({
        height: tokens.size[name],
        borderRadius: tokens.radius[name],
        gap: tokens.space[name].val * 0.2,
      }),
    },
  } as const,
  defaultVariants: {
    size: '$medium',
  },
})

// 3. Crear texto con el mismo contexto (las variantes se sincronizan automáticamente)
export const ButtonText = styled(Text, {
  name: 'ButtonText',
  context: ButtonContext,
  variants: {
    size: {
      '...fontSize': (name, { font }) => ({
        fontSize: font?.size[name],
      }),
    },
  } as const,
})

// 4. Componer con withStaticProperties
export const Button = withStaticProperties(ButtonFrame, {
  Props: ButtonContext.Provider,
  Text: ButtonText,
})

Uso:

<Button size="$large">
  <Button.Text>Click me</Button.Text>
</Button>

// O sobrescribir valores por defecto desde arriba:
<Button.Props size="$small">
  <Button><Button.Text>Small</Button.Text></Button>
</Button.Props>

Nota: El patrón context no funciona con la optimización del compilador. Úsalo para componentes de alto nivel (Button, Card), no para primitivas (Stack, Text).

styleable() para Componentes Envoltorio

Cuando envuelves un componente con estilo en un componente funcional, usa .styleable() para preservar la herencia de variantes:

const StyledText = styled(Text)

// SIN styleable - Herencia de variantes ROTA
const BrokenWrapper = (props) => <StyledText {...props} />

// CON styleable - CORRECTO
const CorrectWrapper = StyledText.styleable((props, ref) => (
  <StyledText ref={ref} {...props} />
))

// Ahora esto funciona:
const StyledCorrectWrapper = styled(CorrectWrapper, {
  variants: {
    bold: { true: { fontWeight: 'bold' } },
  },
})

Agregar Props Extra

Pasa un argumento de tipo genérico para props adicionales:

type ExtraProps = { icon?: React.ReactNode }

const IconText = StyledText.styleable<ExtraProps>((props, ref) => {
  const { icon, ...rest } = props
  return (
    <XStack>
      {icon}
      <StyledText ref={ref} {...rest} />
    </XStack>
  )
})

Prop accept para Componentes Personalizados

Habilita la resolución de tokens/temas en props no estándar:

// Para fill/stroke de SVG que deben aceptar colores de tema
const StyledSVG = styled(SVG, {}, {
  accept: { fill: 'color', stroke: 'color' } as const,
})

// Uso: <StyledSVG fill="$blue10" />

// Para objetos de estilo (como contentContainerStyle de ScrollView)
const MyScrollView = styled(ScrollView, {}, {
  accept: { contentContainerStyle: 'style' } as const,
})

// Uso: <MyScrollView contentContainerStyle={{ padding: '$4' }} />

Importante: Usa as const en el objeto accept.

El Orden de las Props Importa

En styled(), el orden de las props determina la prioridad de sobrescritura:

// backgroundColor puede ser sobrescrito por props
const Overridable = (props) => (
  <View backgroundColor="$red10" {...props} width={200} />
)
// width NO PUEDE ser sobrescrito (viene después del spread)

// El orden de las variantes también importa:
<Component scale={3} huge />  // scale = 3 (scale viene primero)
<Component huge scale={3} />  // scale = 2 (huge sobrescribe)

Anti-Patrones

Estilos Dinámicos Rompen la Optimización

// MALO - rompe la optimización del compilador
<View style={{ width: someVariable * 2 }} />
<View backgroundColor={isDark ? '$gray1' : '$gray12'} />

// BUENO - usa variantes
const Box = styled(View, {
  variants: {
    dark: { true: { backgroundColor: '$gray1' }, false: { backgroundColor: '$gray12' } },
  },
})
<Box dark={isDark} />

Funciones en Línea

// MALO - nueva función en cada render
<View onPress={() => handlePress(id)} />

// BUENO - referencia estable
const handlePressCallback = useCallback(() => handlePress(id), [id])
<View onPress={handlePressCallback} />

Rutas de Importación Incorrectas

// Estos son paquetes diferentes con contenidos diferentes:
import { View } from 'tamagui'           // Kit de UI completo
import { View } from '@tamagui/core'     // Solo núcleo (más pequeño)
import { Button } from '@tamagui/button' // Componente individual

// Elige un enfoque y sé consistente

Mezclar RN StyleSheet con Tamagui

// MALO - los valores de StyleSheet no resuelven tokens
const styles = StyleSheet.create({ box: { padding: 20 } })
<View style={styles.box} backgroundColor="$blue10" />

// BUENO - todo Tamagui
<View padding="$4" backgroundColor="$blue10" />

Ramificación Platform.OS para Dialog/Sheet

// MALO - ramificación manual de plataforma
if (Platform.OS === 'web') {
  return <Dialog>...</Dialog>
}
return <Sheet>...</Sheet>

// BUENO - usa Adapt (ver @DIALOG_PATTERNS.md)
<Dialog>
  <Dialog.Portal>...</Dialog.Portal>
  <Adapt when="sm" platform="touch">
    <Sheet><Adapt.Contents /></Sheet>
  </Adapt>
</Dialog>

Obtener Documentación Actualizada

Para detalles actualizados de la API, obtén los documentos markdown directamente:

# Documentos del núcleo
curl -sL "https://tamagui.dev/docs/core/configuration.md"
curl -sL "https://tamagui.dev/docs/core/styled.md"
curl -sL "https://tamagui.dev/docs/core/variants.md"
curl -sL "https://tamagui.dev/docs/core/animations.md"

# Documentos de componentes
curl -sL "https://tamagui.dev/ui/sheet.md"
curl -sL "https://tamagui.dev/ui/dialog.md"
curl -sL "https://tamagui.dev/ui/select.md"

# Índice completo de documentos
curl -sL "https://tamagui.dev/llms.txt"

Para páginas HTML, usa el skill de web-fetch con los selectores apropiados.

Referencia Rápida

Abreviaturas de Config v4 (alineadas con Tailwind)

AbreviaturaPropiedad
bgbackgroundColor
ppadding
mmargin
wwidth
hheight
brborderRadius

Puntos de Ruptura de Media Query

TokenPredeterminadoPredeterminado del Servidor
$xs660pxtrue
$sm800pxfalse
$md1020pxfalse
$lg1280pxfalse
$xl1420pxfalse

Controladores de Animación

ControladorPlataformaCaso de Uso
cssWebPredeterminado, mejor rendimiento
react-native-reanimatedNativaRequerido para animaciones nativas

Archivos de Patrones Adicionales

  • @DIALOG_PATTERNS.md - Dialog, Sheet, Adapt, accesibilidad
  • @FORM_PATTERNS.md - Form, Input, Label, validación con zod
  • @ANIMATION_PATTERNS.md - Controladores de animación, enterStyle/exitStyle
  • @OVERLAY_PATTERNS.md - Popover, Tooltip, Select
  • @COMPILER_PATTERNS.md - Detalles de optimización del compilador
  • @DESIGN_SYSTEM.md - Tokens de diseño y temas

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Next.js 16+ uses App Router with Server Components by default. Client Components are only used when interactivity is needed (hooks, event handlers, browser APIs).

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Skills relacionados