API

Ver como Markdown Editar en GitHub Documentación de 3843abd

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 descritos al final de esta página.

Para trabajar repetidamente con la misma configuración de CSS, llame una vez a tw::compile() y reutilice el objeto TailwindCompiler devuelto.

PHP

use TailwindPHP\tw;

$css = tw::generate('<div class="flex items-center p-4 bg-blue-500">');

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('<div class="flex p-4">');

// String with custom CSS
$css = tw::generate('<div class="flex bg-brand">', '@import "tailwindcss"; @theme { --color-brand: #3b82f6; }');

// Array input with options
$css = tw::generate([
    'content' => '<div class="flex p-4">',
    '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
`cache`	`bool \| string`	Activar la caché de archivos; consulte Caché
`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() 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('<div class="flex p-4 bg-brand">');

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
`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<string>`	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('<div class="bg-red-500/50">');
// .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 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<string, string> (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(), pero resuelve todas las variables CSS a valores concretos. Devuelve array<string, string>.

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<string>.

PHP

use TailwindPHP\tw;

tw::extractCandidates('<div class="flex p-4" className="bg-blue-500">');
// ['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<string>.

PHP

use TailwindPHP\tw;

$classes = tw::extractCandidatesFromStrings('<?php $wrap = \'p-4 sm:flex\'; $title = "hello world"; ?>');
// ['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(), 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<string, string>.

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. 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('<div class="flex p-4">');
$minified = tw::minify($css);

Consulte Caché y minificación 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<string, string> (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<string, string> (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<string, string> (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('<div class="flex">')`
Cadena + cadena CSS	`tw::generate('<div class="flex">', '@import "tailwindcss"; @theme { ... }')`
Matriz con `content` (+ opcional `css`)	`tw::generate(['content' => '<div class="flex">', '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() 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('<div class="flex p-4 bg-brand">');
$candidates = $compiler->extractCandidates('<div class="flex p-4 bg-brand">');

$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 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()`, excepto `stateCacheFile`
`StateCache\compileCssCached(string $css, string $cacheFile, array $options = []): array`	`compile()` con la caché persistente del estado del compilador
`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' => '<div class="flex p-4">',
    'cache' => true,
]);

// Custom directory + TTL
$css = tw::generate([
    'content' => '<div class="flex p-4">',
    '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() o con la función independiente TailwindPHP\clearCache().

Consulte la guía detallada Caché y minificación.