# API Toda la superficie estática reside en una sola clase: `TailwindPHP\tw` (un alias de la clase interna `Tailwind`). Todos sus métodos se pueden llamar de forma estática, y los métodos de inspección (`properties`, `computedProperties`, `value`, `computedValue`) aceptan los [formatos de entrada](#input-formats) descritos al final de esta página. Para trabajar repetidamente con la misma configuración de CSS, llame una vez a [`tw::compile()`](#twcompile) y reutilice el objeto [`TailwindCompiler`](#tailwindcompiler-instance-methods) devuelto. ```php use TailwindPHP\tw; $css = tw::generate('
'); ``` ## tw::generate() ```php public static function generate(string|array $input, string $css = '@import "tailwindcss";'): string ``` Analiza el contenido, extrae candidatos de clase y devuelve el CSS generado. El `$css` predeterminado es `@import "tailwindcss";`, que incluye tema, preflight y utilidades. **Devuelve** `string`. ```php use TailwindPHP\tw; // String input $css = tw::generate('
'); // String with custom CSS $css = tw::generate('
', '@import "tailwindcss"; @theme { --color-brand: #3b82f6; }'); // Array input with options $css = tw::generate([ 'content' => '
', 'css' => '@import "tailwindcss";', 'minify' => true, ]); ``` La forma de matriz acepta estas claves: | Clave | Tipo | Propósito | |---|---|---| | `content` | `string` | Contenido que se analizará para encontrar candidatos de clase (obligatorio) | | `css` | `string` | Entrada CSS con directivas Tailwind (valor predeterminado `@import "tailwindcss";`) | | `minify` | `bool` | Minificar la salida (valor predeterminado `false`) | | `importPaths` | `string \| array \| callable \| null` | Cargar CSS desde el sistema de archivos con resolución completa de `@import`; consulte [Importación de CSS](https://tailwindphp.inline0.dev/es/docs/usage/imports) | | `cache` | `bool \| string` | Activar la caché de archivos; consulte [Caché](#caching) | | `cacheTtl` | `int` | Duración de la caché en segundos | ## tw::compile() ```php public static function compile(string $css = '@import "tailwindcss";', array $options = []): TailwindCompiler ``` Crea un `TailwindCompiler` reutilizable asociado a la CSS indicada. El análisis y la construcción del sistema de diseño se realizan una sola vez, por lo que es la opción eficiente para generar CSS a partir de muchas cadenas de contenido distintas. Use `generate()` para acumular una hoja de estilos en varias llamadas o [`generateExact()`](#accumulating-vs-exact-generation) para generar una salida independiente por página. **Devuelve** `TailwindCompiler`. ```php use TailwindPHP\tw; // Default Tailwind $compiler = tw::compile(); // Custom CSS $compiler = tw::compile('@import "tailwindcss"; @theme { --color-brand: #3b82f6; }'); $css = $compiler->generate('
'); ``` La matriz `$options` acepta: | Opción | Tipo | Propósito | |---|---|---| | `stateCacheFile` | `string` | Ruta de un archivo PHP que conserva el estado de construcción del compilador entre solicitudes y procesos; consulte [Caché del estado del compilador](https://tailwindphp.inline0.dev/es/docs/advanced/caching#compiler-state-cache) | | `polyfills` | `int` | Qué alternativas emitir, como máscara de bits de `TailwindPHP\POLYFILL_AT_PROPERTY` (valores predeterminados de `@layer properties` para variables `@property`) y `TailwindPHP\POLYFILL_COLOR_MIX` (alternativas de color estáticas antes de `color-mix()`). Valor predeterminado `POLYFILL_ALL`; `POLYFILL_NONE` desactiva ambas | | `importSearchPaths` | `array` | Directorios donde buscar `@import` al resolverlos desde el sistema de archivos | ```php use TailwindPHP\tw; use const TailwindPHP\POLYFILL_NONE; // Cache construction state on disk, reused by later requests $compiler = tw::compile('@import "tailwindcss";', [ 'stateCacheFile' => __DIR__ . '/cache/tailwind-state.php', ]); // Plain output without fallbacks, e.g. for CSS modules $compiler = tw::compile('@import "tailwindcss/utilities.css";', [ 'polyfills' => POLYFILL_NONE, ]); $compiler->generate('
'); // .bg-red-500\/50 { background-color: color-mix(in oklab, var(--color-red-500) 50%, transparent); } // (with the default, a `#fb2c3680` fallback comes first and color-mix() moves into @supports) ``` Consulte [Métodos de instancia de TailwindCompiler](#tailwindcompiler-instance-methods) para ver toda la interfaz de instancia. ## tw::properties() ```php public static function properties(string|array $input, string $css = '@import "tailwindcss";'): array ``` Devuelve las propiedades CSS **sin procesar** de una clase, con las variables CSS sin resolver. **Devuelve** `array` (nombre de propiedad → valor). ```php use TailwindPHP\tw; tw::properties('p-4'); // ['padding' => 'calc(var(--spacing) * 4)'] tw::properties(['flex', 'items-center', 'p-4']); // ['display' => 'flex', 'align-items' => 'center', 'padding' => 'calc(var(--spacing) * 4)'] ``` ## tw::computedProperties() ```php public static function computedProperties(string|array $input, string $css = '@import "tailwindcss";'): array ``` Como [`properties()`](#twproperties), pero resuelve todas las variables CSS a valores concretos. **Devuelve** `array`. ```php use TailwindPHP\tw; tw::computedProperties('p-4'); // ['padding' => '1rem'] tw::computedProperties('text-blue-500'); // ['color' => 'oklch(62.3% .214 259.815)'] tw::computedProperties(['flex', 'items-center', 'gap-4']); // ['display' => 'flex', 'align-items' => 'center', 'gap' => '1rem'] ``` ## tw::value() ```php public static function value(string|array $input, string $css = '@import "tailwindcss";'): ?string ``` Devuelve el valor **sin procesar** de una sola clase de utilidad. **Devuelve** `?string` — `null` si no se encuentra la utilidad. ```php use TailwindPHP\tw; tw::value('p-4'); // 'calc(var(--spacing) * 4)' tw::value('text-blue-500'); // 'var(--color-blue-500)' ``` ## tw::computedValue() ```php public static function computedValue(string|array $input, string $css = '@import "tailwindcss";'): ?string ``` Devuelve el valor **resuelto** de una sola clase de utilidad. **Devuelve** `?string` — `null` si no se encuentra la utilidad. ```php use TailwindPHP\tw; tw::computedValue('p-4'); // '1rem' tw::computedValue('text-blue-500'); // 'oklch(62.3% .214 259.815)' tw::computedValue('gap-4'); // '1rem' ``` ## tw::extractCandidates() ```php public static function extractCandidates(string $html): array ``` Extrae nombres de clase de Tailwind del contenido (lee los atributos `class` y `className`). **Devuelve** `array`. ```php use TailwindPHP\tw; tw::extractCandidates('
'); // ['flex', 'p-4', 'bg-blue-500'] ``` ## tw::extractCandidatesFromStrings() ```php public static function extractCandidatesFromStrings(string $source): array ``` Extrae candidatos a nombres de clase de cada cadena entre comillas simples o dobles en el código fuente, para plantillas que construyen listas de clases en variables en vez de atributos `class`. Divide cada cadena por espacios en blanco y conserva todos los tokens que parecen nombres de clase. **Devuelve** `array`. ```php use TailwindPHP\tw; $classes = tw::extractCandidatesFromStrings(''); // ['p-4', 'sm:flex', 'hello', 'world'] $css = tw::compile()->css($classes); ``` Las palabras comunes también pasan la comprobación (`hello`, `world` arriba); no generan nada al compilar, a menos que coincidan con nombres de utilidades. Pase el resultado a [`css()`](#tailwindcompiler-instance-methods), ya que `generate()` solo lee atributos `class`. ## tw::cssMap() ```php public static function cssMap(string $css = '@import "tailwindcss";'): array ``` Crea un mapa inverso de declaraciones CSS a clases de utilidad, útil para convertir CSS existentes en clases Tailwind. Las claves son cadenas `"property: value"` con las variables resueltas (las utilidades con varias propiedades también tienen una clave `"prop: value; prop: value"`); los valores son nombres de clase. **Devuelve** `array`. ```php use TailwindPHP\tw; $map = tw::cssMap(); $map['display: flex']; // 'flex' $map['padding: 1rem']; // 'p-4' $map['text-align: center']; // 'text-center' $map['color: #fff']; // 'text-white' ``` El mapa abarca una lista fija de utilidades comunes (visualización, posición, flexbox, tipografía, espaciado y tamaños, bordes, colores negro, blanco y transparente, entre otras), no todas las utilidades ni todos los colores del tema. El argumento `$css` cambia los valores resueltos de esas utilidades, pero los tokens de tema personalizados (como `--color-brand`) no añaden entradas. ## tw::minify() ```php public static function minify(string $css): string ``` Minifica una cadena CSS arbitraria: elimina comentarios, reduce espacios en blanco, acorta colores hexadecimales (`#ffffff` → `#fff`), elimina unidades de los valores cero (`0px` → `0`) y más. **Devuelve** `string`. Para el CSS que TailwindPHP genera por sí mismo, prefiera la opción `minify` (`tw::generate(['minify' => true])`) o el parámetro `$minify` de los [métodos del compilador](#tailwindcompiler-instance-methods). Esa ruta minifica durante la serialización, lo que es más rápido y conserva los selectores `:not()` descendientes que el procesamiento de cadenas reduce. ```php use TailwindPHP\tw; $css = tw::generate('
'); $minified = tw::minify($css); ``` Consulte [Caché y minificación](https://tailwindphp.inline0.dev/es/docs/advanced/caching) para ver todas las optimizaciones. ## tw::clearCache() ```php public static function clearCache(string|bool|null $cache = true): int ``` Elimina archivos CSS almacenados en caché. Pase `true` (o no indique nada) para usar el directorio de caché predeterminado, o una ruta para usar un directorio personalizado. **Devuelve** `int`: el número de archivos eliminados. ```php use TailwindPHP\tw; tw::clearCache(); // default directory tw::clearCache('/path/to/cache'); // custom directory ``` También está disponible una función `TailwindPHP\clearCache()` independiente. ## tw::colors() ```php public static function colors(string $css = '@import "tailwindcss";'): array ``` Devuelve todos los valores de color del tema. **Devuelve** `array` (nombre del color → valor calculado). ```php use TailwindPHP\tw; tw::colors(); // ['red-500' => 'oklch(63.7% .237 25.331)', 'blue-500' => 'oklch(62.3% .214 259.815)', ...] // With a custom theme tw::colors('@import "tailwindcss"; @theme { --color-brand: #3b82f6; }'); // [..., 'brand' => '#3b82f6'] ``` ## tw::breakpoints() ```php public static function breakpoints(string $css = '@import "tailwindcss";'): array ``` Devuelve todos los valores de puntos de interrupción del tema. **Devuelve** `array` (nombre del punto de interrupción → valor). ```php use TailwindPHP\tw; tw::breakpoints(); // ['sm' => '40rem', 'md' => '48rem', 'lg' => '64rem', 'xl' => '80rem', '2xl' => '96rem'] tw::breakpoints('@import "tailwindcss"; @theme { --breakpoint-xs: 20rem; }'); // ['sm' => '40rem', ..., '2xl' => '96rem', 'xs' => '20rem'] ``` ## tw::spacing() ```php public static function spacing(string $css = '@import "tailwindcss";'): array ``` Devuelve los valores de espaciado personalizados del tema. **Devuelve** `array` (nombre del espaciado → valor). ```php use TailwindPHP\tw; // TailwindCSS 4 uses a single --spacing base value rather than a --spacing-* namespace. // This returns any custom --spacing-* values defined in the theme. tw::spacing('@import "tailwindcss"; @theme { --spacing-huge: 10rem; }'); // ['huge' => '10rem'] ``` ## Formatos de entrada Los métodos de inspección (`generate`, `properties`, `computedProperties`, `value`, `computedValue`) aceptan tres formatos de entrada: | Formato | Ejemplo | |---|---| | Solo cadena | `tw::generate('
')` | | Cadena + cadena CSS | `tw::generate('
', '@import "tailwindcss"; @theme { ... }')` | | Matriz con `content` (+ opcional `css`) | `tw::generate(['content' => '
', 'css' => '@import "tailwindcss";'])` | ```php use TailwindPHP\tw; // Format 1: string only tw::properties('p-4'); // Format 2: string + CSS tw::properties('bg-brand', '@import "tailwindcss"; @theme { --color-brand: #3b82f6; }'); // Format 3: array tw::properties(['content' => 'p-4', 'css' => '@import "tailwindcss";']); ``` ## Métodos de instancia de TailwindCompiler El objeto que devuelve [`tw::compile()`](#twcompile) expone las mismas funciones de inspección que la clase estática, asociadas al CSS con el que se compiló. Úselo para evitar volver a analizar el tema en cada llamada. ```php public function generate(string $content, bool $minify = false): string public function css(array $candidates, bool $minify = false): string public function generateExact(string $content, bool $minify = false): string public function cssExact(array $candidates, bool $minify = false): string public function extractCandidates(string $html): array public function extractCandidatesFromStrings(string $source): array public function properties(string|array $utilities): array public function computedProperties(string|array $utilities): array public function value(string $utility): ?string public function computedValue(string $utility): ?string public function minify(string $css): string public function colors(): array public function breakpoints(): array public function spacing(): array ``` ```php use TailwindPHP\tw; $compiler = tw::compile('@import "tailwindcss"; @theme { --color-brand: #3b82f6; }'); $css = $compiler->generate('
'); $candidates = $compiler->extractCandidates('
'); $compiler->properties('bg-brand'); // ['background-color' => 'var(--color-brand)'] $compiler->computedProperties('bg-brand'); // ['background-color' => '#3b82f6'] $compiler->value('bg-brand'); // 'var(--color-brand)' $compiler->computedValue('bg-brand'); // '#3b82f6' $minified = $compiler->minify($css); $compiler->colors(); // all color values $compiler->breakpoints(); // all breakpoint values $compiler->spacing(); // custom spacing values ``` ### Acumulación y generación exacta `generate()` y `css()` **acumulan**: cada llamada añade sus candidatos al conjunto creciente del compilador y la hoja de estilos devuelta incluye todo lo visto hasta el momento. Esto sirve para crear una sola hoja de estilos a partir de varias plantillas. `generateExact()` y `cssExact()` compilan **exactamente** el contenido o los candidatos indicados en cada llamada, sin conservar los de llamadas anteriores, pero reutilizan el sistema de diseño ya analizado del compilador. La salida coincide con la de una `tw::generate()` en frío del mismo contenido. Es la forma más rápida de generar CSS por página con un compilador de larga duración: ```php use TailwindPHP\tw; $compiler = tw::compile($themeCss); foreach ($pages as $slug => $html) { $perPageCss[$slug] = $compiler->generateExact($html, true); } ``` Los cuatro métodos aceptan una opción `$minify` opcional que genera CSS minificado durante la serialización, idéntico byte a byte a `tw::generate(['minify' => true])` y más eficiente que minificar después la salida formateada. ### Inspectores avanzados Para inspeccionar directamente el estado compilado: ```php public function getTheme(): Theme public function getDesignSystem(): object public function getCompiled(): array ``` ```php $compiler->getTheme(); // Theme object with resolved values $compiler->getDesignSystem(); // Design system: utilities, variants, etc. $compiler->getCompiled(); // Raw compiled state array ``` Estos métodos devuelven estructuras internas; consulte [Arquitectura](https://tailwindphp.inline0.dev/es/docs/advanced/architecture) para saber qué contienen. ### Funciones de bajo nivel La clase `tw` envuelve varias funciones con espacio de nombres en `TailwindPHP`. Son útiles cuando necesita el resultado de compilación sin procesar en vez de un `TailwindCompiler`: | Función | Propósito | |---|---| | `compile(string $css, array $options = []): array` | Analiza y compila CSS. Devuelve `build` (acumulativo) y cierres `buildExact` que reciben candidatos y un indicador `$minify` opcional, además de `sources`, `root`, `features` y `designSystem`. Acepta las mismas opciones que [`tw::compile()`](#twcompile), excepto `stateCacheFile` | | `StateCache\compileCssCached(string $css, string $cacheFile, array $options = []): array` | `compile()` con la [caché persistente del estado del compilador](https://tailwindphp.inline0.dev/es/docs/advanced/caching#compiler-state-cache) | | `parseCssState()`, `finalizeCssState()`, `compileParsed()` | Las dos etapas del análisis (un estado serializable y luego los cierres reconstruidos a partir de él) y el paso final de ensamblaje que usa `compileCssCached()`. `parseCss()` y `compileAst()` siguen siendo las alternativas equivalentes de un solo paso | ```php use function TailwindPHP\compile; $compiled = compile('@import "tailwindcss";'); $css = $compiled['build'](['flex', 'p-4'], true); // minified ``` ## Caché `tw::generate()` puede almacenar en caché en disco CSS compilado para omitir la recompilación de entradas idénticas. | Opción | Tipo | Predeterminado | Propósito | |---|---|---|---| | `cache` | `bool \| string` | `false` | `true` activa el directorio predeterminado; una ruta guarda la caché allí | | `cacheTtl` | `int` | ninguno | Duración de la caché en segundos; las entradas caducadas se vuelven a compilar | ```php use TailwindPHP\tw; // Default directory: sys_get_temp_dir() . '/tailwindphp' $css = tw::generate([ 'content' => '
', 'cache' => true, ]); // Custom directory + TTL $css = tw::generate([ 'content' => '
', 'cache' => '/path/to/cache', 'cacheTtl' => 3600, // expire after 1 hour ]); ``` La clave de caché se deriva del **contenido**, la **configuración de CSS** y la opción **minify**, por lo que entradas distintas generan archivos de caché diferentes. Elimine entradas con [`tw::clearCache()`](#twclearcache) o con la función independiente `TailwindPHP\clearCache()`. Consulte la guía detallada [Caché y minificación](https://tailwindphp.inline0.dev/es/docs/advanced/caching).