# API Visa statinė sąsaja pateikiama vienoje klasėje: `TailwindPHP\tw` (vidinės klasės `Tailwind` pseudonimas). Kiekvieną metodą galima iškviesti statiškai, o visi tikrinimo metodai (`properties`, `computedProperties`, `value`, `computedValue`) priima [įvesties formatus](#input-formats), aprašytus šio puslapio apačioje. Jei norite pakartotinai atlikti veiksmus su ta pačia CSS konfigūracija, vieną kartą iškvieskite [`tw::compile()`](#twcompile) ir pakartotinai naudokite grąžintą [`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 ``` Išanalizuoja turinį, išskiria klasių kandidatus ir grąžina sugeneruotą CSS. Numatytoji `$css` yra `@import "tailwindcss";`, į kurią įtraukiama tema, preflight ir utilities. **Grąžina** `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, ]); ``` Masyvo forma priima šiuos raktus: | Raktas | Tipas | Paskirtis | |---|---|---| | `content` | `string` | Turinys, kuriame ieškoma klasių kandidatų (privalomas) | | `css` | `string` | Įvesties CSS su Tailwind direktyvomis (numatytoji reikšmė `@import "tailwindcss";`) | | `minify` | `bool` | Sumažinti išvesties dydį (numatytoji reikšmė `false`) | | `importPaths` | `string \| array \| callable \| null` | Įkelti CSS iš failų sistemos, atliekant visą `@import` raišką — žr. [Importavimas CSS](https://tailwindphp.inline0.dev/lt/docs/usage/imports) | | `cache` | `bool \| string` | Įjungti failų spartinimą talpykloje — žr. [Spartinimas talpykloje](#caching) | | `cacheTtl` | `int` | Talpyklos galiojimo trukmė sekundėmis | ## tw::compile() ```php public static function compile(string $css = '@import "tailwindcss";', array $options = []): TailwindCompiler ``` Sukuria pakartotinai naudojamą `TailwindCompiler`, susietą su nurodyta CSS. Analizavimas ir dizaino sistemos kūrimas atliekami vieną kartą, todėl tai efektyvus pasirinkimas, kai reikia generuoti CSS daugeliui skirtingų turinio eilučių. Naudokite `generate()`, kad per iškvietimus sukauptumėte vieną stilių lentelę, arba [`generateExact()`](#accumulating-vs-exact-generation), jei kiekvieno puslapio išvestis turi būti nepriklausoma. **Grąžina** `TailwindCompiler`. ```php use TailwindPHP\tw; // Default Tailwind $compiler = tw::compile(); // Custom CSS $compiler = tw::compile('@import "tailwindcss"; @theme { --color-brand: #3b82f6; }'); $css = $compiler->generate('
'); ``` Masyvas `$options` priima: | Parinktis | Tipas | Paskirtis | |---|---|---| | `stateCacheFile` | `string` | PHP failo kelias; jame kompiliatoriaus kūrimo būsena išsaugoma tarp užklausų ir procesų — žr. [Kompiliatoriaus būsenos talpykla](https://tailwindphp.inline0.dev/lt/docs/advanced/caching#compiler-state-cache) | | `polyfills` | `int` | Kokius atsarginius variantus pateikti, kaip `TailwindPHP\POLYFILL_AT_PROPERTY` bitų kaukę: `@layer properties` (`@property` kintamųjų numatytosios reikšmės) ir `TailwindPHP\POLYFILL_COLOR_MIX` (statinės atsarginės spalvų reikšmės prieš `color-mix()`). Numatytoji reikšmė `POLYFILL_ALL`; `POLYFILL_NONE` išjungia abu variantus | | `importSearchPaths` | `array` | Katalogai, kuriuose ieškoma failų sistemoje esančio `@import` | ```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) ``` Visą egzemplioriaus metodų sąrašą rasite skiltyje [TailwindCompiler egzemplioriaus metodai](#tailwindcompiler-instance-methods). ## tw::properties() ```php public static function properties(string|array $input, string $css = '@import "tailwindcss";'): array ``` Grąžina **neapdorotas** CSS klasės savybes; CSS kintamieji lieka neišspręsti. **Grąžina** `array` (savybės pavadinimas → reikšmė). ```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 ``` Kaip ir [`properties()`](#twproperties), bet kiekvienas CSS kintamasis pakeičiamas konkrečia reikšme. **Grąžina** `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 ``` Grąžina **neapdorotą** vienos utility klasės reikšmę. **Grąžina** `?string` — `null`, jei utility nerasta. ```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 ``` Grąžina **išspręstą** vienos utility klasės reikšmę. **Grąžina** `?string` — `null`, jei utility nerasta. ```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 ``` Iš turinio išskiria Tailwind klasių pavadinimus (perskaito ir `class`, ir `className` atributus). **Grąžina** `array`. ```php use TailwindPHP\tw; tw::extractCandidates('
'); // ['flex', 'p-4', 'bg-blue-500'] ``` ## tw::extractCandidatesFromStrings() ```php public static function extractCandidatesFromStrings(string $source): array ``` Iš šaltinio kodo kiekvienos viengubomis arba dvigubomis kabutėmis apgaubtos eilutės išskiria klasių pavadinimų kandidatus. Tai skirta šablonams, kuriuose klasių sąrašai kuriami kintamuosiuose, o ne `class` atributuose. Kiekviena eilutė suskaidoma pagal tarpus, o visi į klasės pavadinimus panašūs elementai paliekami. **Grąžina** `array`. ```php use TailwindPHP\tw; $classes = tw::extractCandidatesFromStrings(''); // ['p-4', 'sm:flex', 'hello', 'world'] $css = tw::compile()->css($classes); ``` Patikrą pereina ir paprasti žodžiai (aukščiau pateikti `hello`, `world`); jie nieko nekompiliuoja, nebent sutampa su utility pavadinimais. Perduokite rezultatą į [`css()`](#tailwindcompiler-instance-methods), nes `generate()` skaito tik `class` atributus. ## tw::cssMap() ```php public static function cssMap(string $css = '@import "tailwindcss";'): array ``` Sukuria atvirkštinį žemėlapį nuo CSS deklaracijų iki utility klasių. Jis naudingas konvertuojant esamus CSS į Tailwind klases. Raktai yra `"property: value"` eilutės su išspręstais kintamaisiais (kelių savybių utility klasėms taip pat sukuriamas `"prop: value; prop: value"` raktas), reikšmės — klasių pavadinimai. **Grąžina** `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' ``` Žemėlapis apima fiksuotą dažnai naudojamų utility klasių sąrašą (display, position, flexbox, tipografija, tarpai ir dydžiai, kraštinės, juoda, balta ir skaidri spalvos bei panašūs atvejai), bet ne visas utility klases ar temos spalvas. Argumentas `$css` pakeičia šių utility klasių išspręstas reikšmes, tačiau pasirinktiniai temos žetonai (pvz., `--color-brand`) naujų įrašų neprideda. ## tw::minify() ```php public static function minify(string $css): string ``` Sumažina bet kokios CSS eilutės dydį: pašalina komentarus, sutraukia tarpus, sutrumpina šešioliktaines spalvas (`#ffffff` → `#fff`), pašalina vienetus iš nulinių reikšmių (`0px` → `0`) ir atlieka daugiau optimizacijų. **Grąžina** `string`. Jei CSS generuoja pats TailwindPHP, naudokite parinktį `minify` (`tw::generate(['minify' => true])`) arba parametrą `$minify`, skirtą [kompiliatoriaus metodams](#tailwindcompiler-instance-methods). Taip mažinamas dydis serializuojant, todėl tai greičiau ir išsaugomi vidinių elementų `:not()` selektoriai, kuriuos eilutėmis pagrįstas apdorojimas sutraukia. ```php use TailwindPHP\tw; $css = tw::generate('
'); $minified = tw::minify($css); ``` Visą optimizacijų sąrašą rasite skiltyje [Spartinimas talpykloje ir minimizavimas](https://tailwindphp.inline0.dev/lt/docs/advanced/caching). ## tw::clearCache() ```php public static function clearCache(string|bool|null $cache = true): int ``` Pašalina talpykloje išsaugotus CSS failus. Perduokite `true` (arba praleiskite), kad būtų naudojamas numatytasis talpyklos katalogas, arba nurodykite pasirinktinio katalogo kelią. **Grąžina** `int` — pašalintų failų skaičių. ```php use TailwindPHP\tw; tw::clearCache(); // default directory tw::clearCache('/path/to/cache'); // custom directory ``` Taip pat galima naudoti atskirą `TailwindPHP\clearCache()` funkciją. ## tw::colors() ```php public static function colors(string $css = '@import "tailwindcss";'): array ``` Grąžina visas temos spalvų reikšmes. **Grąžina** `array` (spalvos pavadinimas → apskaičiuota reikšmė). ```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 ``` Grąžina visas temos lūžio taškų reikšmes. **Grąžina** `array` (lūžio taško pavadinimas → reikšmė). ```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 ``` Grąžina pasirinktines temos tarpų reikšmes. **Grąžina** `array` (tarpo pavadinimas → reikšmė). ```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'] ``` ## Įvesties formatai Tikrinimo metodai (`generate`, `properties`, `computedProperties`, `value`, `computedValue`) priima tris įvesties formas: | Formatas | Pavyzdys | |---|---| | Tik eilutė | `tw::generate('
')` | | Eilutė + CSS eilutė | `tw::generate('
', '@import "tailwindcss"; @theme { ... }')` | | Masyvas su `content` (+ pasirinktinis `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";']); ``` ## TailwindCompiler egzemplioriaus metodai Objektas, grąžinamas iškvietus [`tw::compile()`](#twcompile), pateikia tokius pačius tikrinimo metodus kaip statinė klasė, susietus su CSS, su kuria buvo kompiliuotas. Naudokite jį, kad nereikėtų kiekvieną kartą iš naujo analizuoti temos. ```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 ``` ### Kaupiamasis ir tikslus generavimas `generate()` ir `css()` **kaupia**: kiekvienas iškvietimas prideda savo kandidatus prie augančio kompiliatoriaus rinkinio, o grąžinta stilių lentelė apima visus iki tol aptiktus elementus. Tai tinka vienai stilių lentelei, kuri kuriama iš kelių šablonų. `generateExact()` ir `cssExact()` kiekvieno iškvietimo metu kompiliuoja **tiksliai** pateiktą turinį arba kandidatus, nieko neperimdami iš ankstesnių iškvietimų, bet pakartotinai naudodami jau išanalizuotą kompiliatoriaus dizaino sistemą. Išvestis sutampa su ta, kurią pateiktų naujas `tw::generate()` to paties turinio kompiliavimas. Tai greičiausias būdas iš vieno ilgai veikiančio kompiliatoriaus sukurti kiekvieno puslapio CSS: ```php use TailwindPHP\tw; $compiler = tw::compile($themeCss); foreach ($pages as $slug => $html) { $perPageCss[$slug] = $compiler->generateExact($html, true); } ``` Visi keturi metodai priima pasirenkamą vėliavėlę `$minify`, kuri serializuojant pateikia minimizuotą CSS. Rezultatas baitas į baitą sutampa su `tw::generate(['minify' => true])` ir reikalauja mažiau išteklių nei vėliau minimizuoti gražiai suformatuotą išvestį. ### Išplėstiniai inspektoriai Norėdami tiesiogiai patikrinti sukompiliuotą būseną: ```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 ``` Tai grąžina vidines struktūras; apie jų turinį žr. [Architektūra](https://tailwindphp.inline0.dev/lt/docs/advanced/architecture). ### Žemesnio lygmens funkcijos Klasė `tw` apgaubia vardų sritimis suskirstytų funkcijų rinkinį, esantį `TailwindPHP`. Jos naudingos, kai reikia ne `TailwindCompiler`, o neapdoroto kompiliavimo rezultato: | Funkcija | Paskirtis | |---|---| | `compile(string $css, array $options = []): array` | Išanalizuoja ir kompiliuoja CSS. Grąžina `build` (kaupiamąją) ir `buildExact` uždarinių funkcijų, kurios priima kandidatus ir pasirenkamą `$minify` vėliavėlę, taip pat `sources`, `root`, `features` ir `designSystem`. Priima tas pačias parinktis kaip [`tw::compile()`](#twcompile), išskyrus `stateCacheFile` | | `StateCache\compileCssCached(string $css, string $cacheFile, array $options = []): array` | `compile()` su nuolatine [kompiliatoriaus būsenos talpykla](https://tailwindphp.inline0.dev/lt/docs/advanced/caching#compiler-state-cache) | | `parseCssState()`, `finalizeCssState()`, `compileParsed()` | Dvi analizavimo dalys (serializuojama būsena, tada iš jos atkurtos uždarinių funkcijų) ir galutinis surinkimo žingsnis, kurį naudoja `compileCssCached()`. `parseCss()` ir `compileAst()` išlieka vieno žingsnio atitikmenimis | ```php use function TailwindPHP\compile; $compiled = compile('@import "tailwindcss";'); $css = $compiled['build'](['flex', 'p-4'], true); // minified ``` ## Spartinančioji talpykla `tw::generate()` gali išsaugoti sukompiliuotą CSS diske, kad identiškų įvesčių nereikėtų kompiliuoti iš naujo. | Parinktis | Tipas | Numatytoji reikšmė | Paskirtis | |---|---|---|---| | `cache` | `bool \| string` | `false` | `true` įjungia numatytąjį katalogą; nurodžius kelią, talpykla naudojama jame | | `cacheTtl` | `int` | nėra | Talpyklos galiojimo trukmė sekundėmis; pasibaigus galiojimui, įrašai kompiliuojami iš naujo | ```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 ]); ``` Talpyklos raktas sudaromas pagal **turinį**, **CSS konfigūraciją** ir **minify** parinktį, todėl skirtingoms įvestims sukuriami skirtingi talpyklos failai. Įrašus išvalykite naudodami [`tw::clearCache()`](#twclearcache) arba atskirą `TailwindPHP\clearCache()` funkciją. Išsamesnį vadovą rasite skiltyje [Spartinimas talpykloje ir minimizavimas](https://tailwindphp.inline0.dev/lt/docs/advanced/caching).