# API Î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](#input-formats) descrise la finalul acestei pagini. Pentru operații repetate cu aceeași configurație CSS, apelați o dată [`tw::compile()`](#twcompile) și reutilizați valoarea returnată [`TailwindCompiler`](#tailwindcompiler-instance-methods). ```php use TailwindPHP\tw; $css = tw::generate('
'); ``` ## 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('
'); // 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, ]); ``` 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](https://tailwindphp.inline0.dev/ro/docs/usage/imports) | | `cache` | `bool \| string` | Activează stocarea în cache a fișierelor — vezi [Memorarea în cache](#caching) | | `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()`](#accumulating-vs-exact-generation) 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('
'); ``` 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](https://tailwindphp.inline0.dev/ro/docs/advanced/caching#compiler-state-cache) | | `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` | 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('
'); // .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](#tailwindcompiler-instance-methods) 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` (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()`](#twproperties), dar cu fiecare variabilă CSS rezolvată la o valoare concretă. **Returnează** `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 ``` 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`. ```php use TailwindPHP\tw; tw::extractCandidates('
'); // ['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`. ```php use TailwindPHP\tw; $classes = tw::extractCandidatesFromStrings(''); // ['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()`](#tailwindcompiler-instance-methods), 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`. ```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](#tailwindcompiler-instance-methods). 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('
'); $minified = tw::minify($css); ``` Consultați [Memorarea în cache și minificarea](https://tailwindphp.inline0.dev/ro/docs/advanced/caching) 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` (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` (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` (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('
')` | | Șir + șir CSS | `tw::generate('
', '@import "tailwindcss"; @theme { ... }')` | | Array cu `content` (+ opțional `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";']); ``` ## Metode de instanță TailwindCompiler Obiectul returnat de [`tw::compile()`](#twcompile) 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('
'); $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 ``` ### 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](https://tailwindphp.inline0.dev/ro/docs/advanced/architecture) 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()`](#twcompile), cu excepția `stateCacheFile` | | `StateCache\compileCssCached(string $css, string $cacheFile, array $options = []): array` | `compile()` folosind [cache-ul persistent al stării compilatorului](https://tailwindphp.inline0.dev/ro/docs/advanced/caching#compiler-state-cache) | | `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' => '
', 'cache' => true, ]); // Custom directory + TTL $css = tw::generate([ 'content' => '
', '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()`](#twclearcache) sau cu funcția de sine stătătoare `TailwindPHP\clearCache()`. Pentru ghidul detaliat, consultați [Memorarea în cache și minificarea](https://tailwindphp.inline0.dev/ro/docs/advanced/caching).