# API Visa statisko metožu kopa atrodas vienā klasē: `TailwindPHP\tw` (iekšējās klases `Tailwind` aizstājvārds). Visas metodes var izsaukt statiski, un pārbaudes metodes (`properties`, `computedProperties`, `value`, `computedValue`) pieņem [ievades formātus](#input-formats), kas aprakstīti šīs lapas apakšdaļā. Atkārtotām darbībām ar vienu un to pašu CSS konfigurāciju vienreiz izsauciet [`tw::compile()`](#twcompile) un atkārtoti izmantojiet atgriezto [`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 ``` Parsē saturu, iegūst klašu kandidātus un atgriež ģenerēto CSS. Noklusējuma `$css` ir `@import "tailwindcss";`; tā iekļauj motīvu, preflight un utilītas. **Atgriež** `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, ]); ``` Masīva formā tiek pieņemtas šādas atslēgas: | Atslēga | Tips | Nolūks | |---|---|---| | `content` | `string` | Saturs, kurā meklēt klašu kandidātus (obligāts) | | `css` | `string` | Ievades CSS ar Tailwind direktīvām (noklusējums `@import "tailwindcss";`) | | `minify` | `bool` | Minificēt izvadi (noklusējums `false`) | | `importPaths` | `string \| array \| callable \| null` | Ielādēt CSS no failu sistēmas ar pilnu `@import` atrisināšanu — skatiet [Importēšana: CSS](https://tailwindphp.inline0.dev/lv/docs/usage/imports) | | `cache` | `bool \| string` | Iespējot failu kešatmiņu — skatiet [Kešatmiņa](#caching) | | `cacheTtl` | `int` | Kešatmiņas darbības ilgums sekundēs | ## tw::compile() ```php public static function compile(string $css = '@import "tailwindcss";', array $options = []): TailwindCompiler ``` Izveido atkārtoti izmantojamu `TailwindCompiler`, kas piesaistīts norādītajam CSS. Parsēšana un dizaina sistēmas izveide notiek vienreiz, tāpēc šī ir efektīva izvēle, ja CSS jāģenerē vairākām dažādām satura virknēm. Izmantojiet `generate()`, lai vairākos izsaukumos uzkrātu vienu stilu lapu, vai [`generateExact()`](#accumulating-vs-exact-generation) neatkarīgai katras lapas izvadei. **Atgriež** `TailwindCompiler`. ```php use TailwindPHP\tw; // Default Tailwind $compiler = tw::compile(); // Custom CSS $compiler = tw::compile('@import "tailwindcss"; @theme { --color-brand: #3b82f6; }'); $css = $compiler->generate('
'); ``` Masīvs `$options` pieņem šādas opcijas: | Opcija | Tips | Nolūks | |---|---|---| | `stateCacheFile` | `string` | Ceļš uz PHP failu, kurā tiek saglabāts kompilatora izveides stāvoklis starp pieprasījumiem un procesiem — skatiet [Kompilatora stāvokļa kešatmiņa](https://tailwindphp.inline0.dev/lv/docs/advanced/caching#compiler-state-cache) | | `polyfills` | `int` | Nosaka, kuras rezerves vērtības izvadīt kā `TailwindPHP\POLYFILL_AT_PROPERTY` bitmasku (`@layer properties` noklusētās vērtības `@property` mainīgajiem) un `TailwindPHP\POLYFILL_COLOR_MIX` (statiskās krāsu rezerves vērtības pirms `color-mix()`). Noklusējums `POLYFILL_ALL`; `POLYFILL_NONE` atspējo abas | | `importSearchPaths` | `array` | Mapes, kurās meklēt, risinot `@import` no failu sistēmas | ```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) ``` Pilnu instanču metožu klāstu skatiet [TailwindCompiler instances metodes](#tailwindcompiler-instance-methods). ## tw::properties() ```php public static function properties(string|array $input, string $css = '@import "tailwindcss";'): array ``` Atgriež neapstrādātos CSS rekvizītus klasei, atstājot CSS mainīgos neatrisinātus. **Atgriež** `array` (rekvizīta nosaukums → vērtība). ```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 ``` Līdzīgi kā [`properties()`](#twproperties), bet katrs CSS mainīgais tiek atrisināts līdz konkrētai vērtībai. **Atgriež** `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 ``` Atgriež vienas utilītas klases neapstrādāto vērtību. **Atgriež** `?string` — `null`, ja utilīta nav atrasta. ```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 ``` Atgriež vienas utilītas klases atrisināto vērtību. **Atgriež** `?string` — `null`, ja utilīta nav atrasta. ```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 ``` No satura iegūst Tailwind klašu nosaukumus (nolasa gan `class`, gan `className` atribūtus). **Atgriež** `array`. ```php use TailwindPHP\tw; tw::extractCandidates('
'); // ['flex', 'p-4', 'bg-blue-500'] ``` ## tw::extractCandidatesFromStrings() ```php public static function extractCandidatesFromStrings(string $source): array ``` Izvelk klašu nosaukumu kandidātus no katras vienpēdiņās vai dubultpēdiņās ietvertas virknes avota kodā. Tas noder veidnēm, kurās klašu saraksti tiek veidoti mainīgajos, nevis `class` atribūtos. Katra virkne tiek sadalīta pēc atstarpēm, un tiek paturēts katrs tokens, kas izskatās pēc klases nosaukuma. **Atgriež** `array`. ```php use TailwindPHP\tw; $classes = tw::extractCandidatesFromStrings(''); // ['p-4', 'sm:flex', 'hello', 'world'] $css = tw::compile()->css($classes); ``` Pārbaudi iztur arī parasti vārdi (skatiet piemērus `hello` un `world` iepriekš); tie neko neģenerē, ja vien nav utilītklases nosaukumi. Padodiet rezultātu funkcijai [`css()`](#tailwindcompiler-instance-methods), jo `generate()` nolasa tikai `class` atribūtus. ## tw::cssMap() ```php public static function cssMap(string $css = '@import "tailwindcss";'): array ``` Izveido apgriezto karti no CSS deklarācijām uz utilītklasēm; tā noder esošo CSS pārveidošanai par Tailwind klasēm. Atslēgas ir `"property: value"` virknes ar atrisinātiem mainīgajiem (utilītas ar vairākām īpašībām saņem arī `"prop: value; prop: value"` atslēgu), vērtības ir klašu nosaukumi. **Atgriež** `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' ``` Karte aptver noteiktu bieži lietotu utilītu sarakstu (attēlojums, pozicionēšana, flexbox, tipogrāfija, atstarpes un izmēru soļi, apmales, melnā/baltā/caurspīdīgā krāsa un līdzīgas utilītas), nevis visas utilītas vai motīva krāsas. Arguments `$css` maina šo utilītu atrisinātās vērtības, taču pielāgoti motīva tokeni (piemēram, `--color-brand`) jaunus ierakstus nepievieno. ## tw::minify() ```php public static function minify(string $css): string ``` Samazina patvaļīgu CSS virkni: noņem komentārus, saspiež atstarpes, saīsina heksadecimālās krāsas (`#ffffff` → `#fff`), noņem mērvienības no nulles vērtībām (`0px` → `0`) un veic citas optimizācijas. **Atgriež** `string`. Ja CSS ģenerē TailwindPHP pats, dodiet priekšroku opcijai `minify` (`tw::generate(['minify' => true])`) vai parametram `$minify` metodēs [kompilators metodēm](#tailwindcompiler-instance-methods). Šajā ceļā saturs tiek samazināts serializācijas laikā, kas ir ātrāk un saglabā pakārtotos `:not()` selektorus, kurus virkņu apstrādes solis sapludina. ```php use TailwindPHP\tw; $css = tw::generate('
'); $minified = tw::minify($css); ``` Pilnu optimizāciju sarakstu skatiet sadaļā [Kešošana un saspiešana](https://tailwindphp.inline0.dev/lv/docs/advanced/caching). ## tw::clearCache() ```php public static function clearCache(string|bool|null $cache = true): int ``` Dzēš kešotās CSS datnes. Norādiet `true` (vai izlaidiet to), lai izmantotu noklusējuma kešatmiņas direktoriju, vai ceļa virkni, lai izmantotu pielāgotu direktoriju. **Atgriež** `int` — dzēsto datņu skaitu. ```php use TailwindPHP\tw; tw::clearCache(); // default directory tw::clearCache('/path/to/cache'); // custom directory ``` Pieejama arī atsevišķa `TailwindPHP\clearCache()` funkcija. ## tw::colors() ```php public static function colors(string $css = '@import "tailwindcss";'): array ``` Atgriež visas motīva krāsu vērtības. **Atgriež** `array` (krāsas nosaukums → aprēķinātā vērtība). ```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 ``` Atgriež visas motīva pārtraukumpunktu vērtības. **Atgriež** `array` (pārtraukumpunkta nosaukums → vērtība). ```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 ``` Atgriež pielāgotās motīva atstarpju vērtības. **Atgriež** `array` (atstarpes nosaukums → vērtība). ```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'] ``` ## Ievades formāti Pārbaudes metodes (`generate`, `properties`, `computedProperties`, `value`, `computedValue`) pieņem trīs ievades formas: | Formāts | Piemērs | |---|---| | Tikai virkne | `tw::generate('
')` | | Virkne + CSS virkne | `tw::generate('
', '@import "tailwindcss"; @theme { ... }')` | | Masīvs ar `content` (+ neobligātu `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 instances metodes Objekts, ko atgriež [`tw::compile()`](#twcompile), piedāvā tādas pašas pārbaudes iespējas kā statiskā klase, piesaistītas CSS, ar kuru tas tika kompilēts. Izmantojiet to, lai katrā izsaukumā nebūtu atkārtoti jāparsē motīvs. ```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 ``` ### Uzkrājoša un precīza ģenerēšana `generate()` un `css()` **uzkrāj** kandidātus: katrs izsaukums pievieno tos kompilatora augošajai kopai, un atgrieztā stila lapa aptver visu līdz šim redzēto. Tas noder vienas stila lapas veidošanai no vairākām veidnēm. `generateExact()` un `cssExact()` katrā izsaukumā kompilē **precīzi** norādīto saturu vai kandidātus, nesaglabājot iepriekšējo izsaukumu rezultātus, vienlaikus atkārtoti izmantojot kompilatora parsēto dizaina sistēmu. Izvade atbilst tam, ko iegūtu, veicot jaunu `tw::generate()` ar to pašu saturu. Tas ir ātrākais veids, kā no viena ilgstoši izmantota kompilatora veidot katrai lapai atsevišķu CSS: ```php use TailwindPHP\tw; $compiler = tw::compile($themeCss); foreach ($pages as $slug => $html) { $perPageCss[$slug] = $compiler->generateExact($html, true); } ``` Visas četras metodes pieņem neobligātu karodziņu `$minify`, kas serializācijas laikā ģenerē samazinātu CSS, kuras baitu saturs ir identisks `tw::generate(['minify' => true])` un kuras izveide prasa mazāk resursu nekā glītās izvades samazināšana pēc tam. ### Papildu pārbaudes rīki Lai tieši pārbaudītu kompilēto stāvokli: ```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 ``` Tie atgriež iekšējās struktūras; informāciju par to saturu skatiet sadaļā [Arhitektūra](https://tailwindphp.inline0.dev/lv/docs/advanced/architecture). ### Zemāka līmeņa funkcijas Klase `tw` apvieno nosaukumtelpā ietvertu funkciju kopu no `TailwindPHP`. Tās ir noderīgas, ja nepieciešams neapstrādāts kompilēšanas rezultāts, nevis `TailwindCompiler`: | Funkcija | Nolūks | |---|---| | `compile(string $css, array $options = []): array` | Parsē un kompilē CSS. Atgriež `build` (uzkrājošas) un `buildExact` aizvēršanas funkcijas, kas pieņem kandidātus un neobligātu karodziņu `$minify`, kā arī `sources`, `root`, `features` un `designSystem`. Pieņem tās pašas opcijas, ko [`tw::compile()`](#twcompile), izņemot `stateCacheFile` | | `StateCache\compileCssCached(string $css, string $cacheFile, array $options = []): array` | `compile()` ar noturīgo [kompilatora stāvokļa kešatmiņu](https://tailwindphp.inline0.dev/lv/docs/advanced/caching#compiler-state-cache) | | `parseCssState()`, `finalizeCssState()`, `compileParsed()` | Divas parsēšanas daļas (serializējams stāvoklis, pēc tam no tā atjaunotas aizvēršanas funkcijas) un pēdējais salikšanas solis, ko izmanto `compileCssCached()`. `parseCss()` un `compileAst()` joprojām ir vienas darbības ekvivalenti | ```php use function TailwindPHP\compile; $compiled = compile('@import "tailwindcss";'); $css = $compiled['build'](['flex', 'p-4'], true); // minified ``` ## Kešatmiņa `tw::generate()` var kešot kompilēto CSS diskā, lai identiskas ievades netiktu kompilētas atkārtoti. | Opcija | Tips | Noklusējums | Nolūks | |---|---|---|---| | `cache` | `bool \| string` | `false` | `true` iespējo noklusējuma direktoriju; ceļa virkne liek kešot norādītajā vietā | | `cacheTtl` | `int` | nav | Kešatmiņas ilgums sekundēs; ieraksti, kuru derīguma termiņš beidzies, tiek kompilēti atkārtoti | ```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 ]); ``` Kešatmiņas atslēgu nosaka **saturs**, **CSS konfigurācija** un opcija **minify**, tāpēc atšķirīgām ievadēm tiek izveidotas atšķirīgas kešatmiņas datnes. Ierakstus var notīrīt ar [`tw::clearCache()`](#twclearcache) vai atsevišķo funkciju `TailwindPHP\clearCache()`. Plašāku ceļvedi skatiet sadaļā [Kešošana un saspiešana](https://tailwindphp.inline0.dev/lv/docs/advanced/caching).