API

Vizualizați ca Markdown Editați pe GitHub Documentație la 3843abd

Întreaga interfață statică se află într-o singură clasă: TailwindPHP\tw (un alias al clasei interne Tailwind). Fiecare metodă poate fi apelată static, iar metodele de inspectare (properties, computedProperties, value, computedValue) acceptă toate formatele de intrare descrise la finalul acestei pagini.

Pentru operații repetate cu aceeași configurație CSS, apelați o dată tw::compile() și reutilizați valoarea returnată TailwindCompiler.

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

Analizează conținutul, extrage candidații pentru clase și returnează CSS generat. Valoarea implicită pentru $css este @import "tailwindcss";, care include tema, preflight-ul și utilitarele. Returnează 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,
]);

Forma de tip array acceptă aceste chei:

Cheie	Tip	Scop
`content`	`string`	Conținutul în care se caută candidați pentru clase (obligatoriu)
`css`	`string`	Intrare CSS cu directive Tailwind (implicit `@import "tailwindcss";`)
`minify`	`bool`	Minifică rezultatul (implicit `false`)
`importPaths`	`string \| array \| callable \| null`	Încarcă CSS din sistemul de fișiere, cu rezoluție completă `@import` — vezi Importul CSS
`cache`	`bool \| string`	Activează stocarea în cache a fișierelor — vezi Memorarea în cache
`cacheTtl`	`int`	Durata de viață a memoriei cache, în secunde

tw::compile()

PHP

public static function compile(string $css = '@import "tailwindcss";', array $options = []): TailwindCompiler

Creează un TailwindCompiler reutilizabil, asociat cu CSS dat. Analiza și construirea sistemului de design au loc o singură dată, deci aceasta este alegerea eficientă când generați CSS pentru multe șiruri de conținut diferite. Folosiți generate() pentru a acumula o foaie de stiluri la fiecare apel sau generateExact() pentru un rezultat independent pentru fiecare pagină. Returnează 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">');

Array-ul $options acceptă:

Opțiune	Tip	Scop
`stateCacheFile`	`string`	Calea către un fișier PHP care păstrează starea de construire a compilatorului între solicitări și procese — vezi Cache-ul stării compilatorului
`polyfills`	`int`	Ce valori de rezervă să emită, ca mască de biți pentru `TailwindPHP\POLYFILL_AT_PROPERTY` (valorile implicite `@layer properties` pentru variabilele `@property`) și `TailwindPHP\POLYFILL_COLOR_MIX` (valori de rezervă pentru culori statice înainte de `color-mix()`). Valoare implicită `POLYFILL_ALL`; `POLYFILL_NONE` le dezactivează pe ambele
`importSearchPaths`	`array<string>`	Directoarele în care se caută `@import` în sistemul de fișiere

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)

Consultați Metodele de instanță TailwindCompiler pentru lista completă a metodelor instanței.

tw::properties()

PHP

public static function properties(string|array $input, string $css = '@import "tailwindcss";'): array

Returnează proprietățile brute CSS pentru o clasă, fără a rezolva variabilele CSS. Returnează array<string, string> (numele proprietății → valoare).

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

La fel ca properties(), dar cu fiecare variabilă CSS rezolvată la o valoare concretă. Returnează 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

Returnează valoarea brută pentru o singură clasă utilitară. Returnează ?string — null dacă utilitarul nu este găsit.

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

Returnează valoarea rezolvată pentru o singură clasă utilitară. Returnează ?string — null dacă utilitarul nu este găsit.

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

Extrage numele claselor Tailwind din conținut (citește atât atributele class, cât și className). Returnează 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

Extrage candidați pentru nume de clase din fiecare șir delimitat de ghilimele simple sau duble din codul sursă, pentru șabloanele care construiesc liste de clase în variabile în locul atributelor class. Fiecare șir este împărțit după spațiile albe și se păstrează fiecare token care pare a fi un nume de clasă. Returnează 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);

Și cuvintele obișnuite trec verificarea (cele hello, world de mai sus); nu generează nimic decât dacă sunt nume de utilitare. Transmiteți rezultatul către css(), deoarece generate() citește doar atributele class.

tw::cssMap()

PHP

public static function cssMap(string $css = '@import "tailwindcss";'): array

Construiește o mapare inversă de la declarațiile CSS la clase utilitare, utilă pentru conversia codului CSS existent în clase Tailwind. Cheile sunt șiruri "property: value" cu variabilele rezolvate (utilitarele cu mai multe proprietăți primesc și o cheie "prop: value; prop: value"), iar valorile sunt nume de clase. Returnează 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'

Maparea acoperă o listă fixă de utilitare uzuale (afișare, poziționare, flexbox, tipografie, pași de spațiere și dimensionare, borduri, culorile negru/alb/transparent și altele similare), nu fiecare utilitar sau culoare din temă. Argumentul $css schimbă valorile rezolvate ale acestor utilitare, dar tokenurile personalizate ale temei (precum --color-brand) nu adaugă intrări.

tw::minify()

PHP

public static function minify(string $css): string

Minifică un șir CSS arbitrar: elimină comentariile, comprimă spațiile albe, scurtează culorile hexazecimale (#ffffff → #fff), elimină unitățile din valorile zero (0px → 0) și altele. Returnează string.

Pentru CSS pe care TailwindPHP le generează, preferați opțiunea minify (tw::generate(['minify' => true])) sau parametrul $minify al metodelor compilatorului. Această metodă minifică în timpul serializării, ceea ce este mai rapid și păstrează selectorii descendenți :not() pe care procesarea bazată pe șiruri îi comprimă.

PHP

use TailwindPHP\tw;

$css = tw::generate('<div class="flex p-4">');
$minified = tw::minify($css);

Consultați Memorarea în cache și minificarea pentru setul complet de optimizări.

tw::clearCache()

PHP

public static function clearCache(string|bool|null $cache = true): int

Șterge fișierele CSS din cache. Transmiteți true (sau omiteți-l) pentru directorul implicit al memoriei cache, ori un șir cu o cale pentru un director personalizat. Returnează int — numărul de fișiere șterse.

PHP

use TailwindPHP\tw;

tw::clearCache();                  // default directory
tw::clearCache('/path/to/cache');  // custom directory

Este disponibilă și o funcție TailwindPHP\clearCache() autonomă.

tw::colors()

PHP

public static function colors(string $css = '@import "tailwindcss";'): array

Returnează toate valorile culorilor din temă. Returnează array<string, string> (numele culorii → valoarea calculată).

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

Returnează toate valorile punctelor de întrerupere din temă. Returnează array<string, string> (numele punctului de întrerupere → valoare).

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

Returnează valorile personalizate de spațiere din temă. Returnează array<string, string> (numele spațierii → valoare).

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']

Formate de intrare

Metodele de inspectare (generate, properties, computedProperties, value, computedValue) acceptă trei forme de intrare:

Format	Exemplu
Doar șir	`tw::generate('<div class="flex">')`
Șir + șir CSS	`tw::generate('<div class="flex">', '@import "tailwindcss"; @theme { ... }')`
Array cu `content` (+ opțional `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";']);

Metode de instanță TailwindCompiler

Obiectul returnat de tw::compile() expune aceleași funcții de inspectare ca și clasa statică, asociate cu CSS cu care a fost compilat. Folosiți-l pentru a evita reanalizarea temei la fiecare apel.

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

Generare cumulativă și exactă

generate() și css() acumulează: fiecare apel adaugă candidații la setul în creștere al compilatorului, iar foaia de stiluri returnată acoperă tot ce s-a întâlnit până atunci. Este potrivit pentru o singură foaie de stiluri construită treptat din șabloane.

generateExact() și cssExact() compilează exact conținutul sau candidații furnizați la fiecare apel, fără a-i prelua din apelurile precedente, reutilizând totodată sistemul de design analizat al compilatorului. Rezultatul corespunde celui produs de o compilare tw::generate() la rece pentru același conținut. Aceasta este cea mai rapidă metodă de a crea CSS pentru fiecare pagină cu un singur compilator de lungă durată:

PHP

use TailwindPHP\tw;

$compiler = tw::compile($themeCss);

foreach ($pages as $slug => $html) {
    $perPageCss[$slug] = $compiler->generateExact($html, true);
}

Toate cele patru metode acceptă un indicator opțional $minify care emite CSS minificat în timpul serializării, identic la nivel de octeți cu tw::generate(['minify' => true]) și mai eficient decât minificarea ulterioară a rezultatului formatat.

Inspectori avansați

Pentru examinarea directă a stării compilate:

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

Acestea returnează structuri interne; consultați Arhitectura pentru detalii despre conținutul lor.

Funcții de nivel inferior

Clasa tw învelește un set de funcții cu nume de spațiu din TailwindPHP. Sunt utile când aveți nevoie de rezultatul brut al compilării, nu de un TailwindCompiler:

Funcție	Scop
`compile(string $css, array $options = []): array`	Analizează și compilează CSS. Returnează închiderile `build` (cumulative) și `buildExact` care acceptă candidați și un indicator opțional `$minify`, plus `sources`, `root`, `features` și `designSystem`. Acceptă aceleași opțiuni ca `tw::compile()`, cu excepția `stateCacheFile`
`StateCache\compileCssCached(string $css, string $cacheFile, array $options = []): array`	`compile()` folosind cache-ul persistent al stării compilatorului
`parseCssState()`, `finalizeCssState()`, `compileParsed()`	Cele două etape ale analizei (o stare serializabilă, apoi închiderile reconstruite din ea) și pasul final de asamblare folosit de `compileCssCached()`. `parseCss()` și `compileAst()` rămân echivalentele într-un singur pas

PHP

use function TailwindPHP\compile;

$compiled = compile('@import "tailwindcss";');
$css = $compiled['build'](['flex', 'p-4'], true); // minified

Memorarea în cache

tw::generate() poate stoca în cache pe disc CSS compilat, astfel încât intrările identice să nu mai necesite recompilare.

Opțiune	Tip	Implicit	Scop
`cache`	`bool \| string`	`false`	`true` activează directorul implicit; un șir cu o cale stochează în cache în acel director
`cacheTtl`	`int`	niciuna	Durata de viață a memoriei cache, în secunde; intrările expirate sunt recompilate

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
]);

Cheia cache-ului este derivată din conținut, configurația CSS și opțiunea minify, astfel încât intrări diferite generează fișiere cache diferite. Ștergeți intrările cu tw::clearCache() sau cu funcția de sine stătătoare TailwindPHP\clearCache().

Pentru ghidul detaliat, consultați Memorarea în cache și minificarea.