# API Celotna statična površina je na voljo v enem razredu: `TailwindPHP\tw` (vzdevek notranjega razreda `Tailwind`). Vsako metodo je mogoče klicati statično, vse metode za pregled (`properties`, `computedProperties`, `value`, `computedValue`) pa sprejemajo [podprte vhodne formate](#input-formats), opisane na dnu te strani. Pri ponavljajočem delu z isto konfiguracijo CSS enkrat pokličite [`tw::compile()`](#twcompile) in znova uporabite vrnjeni [`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 ``` Razčleni vsebino, izlušči kandidate za razrede in vrne ustvarjeni CSS. Privzeti `$css` je `@import "tailwindcss";`, ki vključuje temo, prednastavitve in pripomočke. **Vrne** `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, ]); ``` Oblika z matriko sprejema te ključe: | Ključ | Vrsta | Namen | |---|---|---| | `content` | `string` | Vsebina, v kateri išče kandidate za razrede (obvezno) | | `css` | `string` | Vhodni CSS z direktivami Tailwind (privzeto `@import "tailwindcss";`) | | `minify` | `bool` | Zmanjša velikost izhoda (privzeto `false`) | | `importPaths` | `string \| array \| callable \| null` | Naloži CSS iz datotečnega sistema s polnim razreševanjem `@import` — glejte [Uvažanje CSS](https://tailwindphp.inline0.dev/sl/docs/usage/imports) | | `cache` | `bool \| string` | Omogoči predpomnjenje datotek — glejte [Predpomnjenje](#caching) | | `cacheTtl` | `int` | Življenjska doba predpomnilnika v sekundah | ## tw::compile() ```php public static function compile(string $css = '@import "tailwindcss";', array $options = []): TailwindCompiler ``` Ustvari ponovno uporabljiv `TailwindCompiler`, vezan na podani CSS. Razčlenjevanje in izdelava sistema zasnove se izvedeta enkrat, zato je to učinkovita izbira pri ustvarjanju CSS za veliko različnih nizov vsebine. Uporabite `generate()` za postopno sestavljanje enega slogovnega lista v več klicih ali [`generateExact()`](#accumulating-vs-exact-generation) za neodvisen izhod za vsako stran. **Vrne** `TailwindCompiler`. ```php use TailwindPHP\tw; // Default Tailwind $compiler = tw::compile(); // Custom CSS $compiler = tw::compile('@import "tailwindcss"; @theme { --color-brand: #3b82f6; }'); $css = $compiler->generate('
'); ``` Matrika `$options` sprejema: | Možnost | Vrsta | Namen | |---|---|---| | `stateCacheFile` | `string` | Pot do datoteke PHP, ki ohranja stanje konstrukcije prevajalnika med zahtevami in procesi — glejte [Predpomnilnik stanja prevajalnika](https://tailwindphp.inline0.dev/sl/docs/advanced/caching#compiler-state-cache) | | `polyfills` | `int` | Katere nadomestne vrednosti vključiti, kot bitno masko `TailwindPHP\POLYFILL_AT_PROPERTY` (privzete vrednosti `@layer properties` za spremenljivke `@property`) in `TailwindPHP\POLYFILL_COLOR_MIX` (statične nadomestne barve pred `color-mix()`). Privzeto `POLYFILL_ALL`; `POLYFILL_NONE` onemogoči oboje | | `importSearchPaths` | `array` | Imeniki, v katerih išče pri razreševanju `@import` iz datotečnega sistema | ```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) ``` Celoten seznam metod primerka najdete v poglavju [Metode primerka TailwindCompiler](#tailwindcompiler-instance-methods). ## tw::properties() ```php public static function properties(string|array $input, string $css = '@import "tailwindcss";'): array ``` Vrne **surove** lastnosti CSS za razred, pri čemer spremenljivke CSS ostanejo nerazrešene. **Vrne** `array` (ime lastnosti → vrednost). ```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 ``` Podobno kot [`properties()`](#twproperties), vendar razreši vsako spremenljivko CSS v konkretno vrednost. **Vrne** `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 ``` Vrne **surovo** vrednost za posamezen razred pripomočka. **Vrne** `?string` — `null`, če pripomočka ni mogoče najti. ```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 ``` Vrne **razrešeno** vrednost za posamezen razred pripomočka. **Vrne** `?string` — `null`, če pripomočka ni mogoče najti. ```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 ``` Izlušči imena razredov Tailwind iz vsebine (bere atribute `class` in `className`). **Vrne** `array`. ```php use TailwindPHP\tw; tw::extractCandidates('
'); // ['flex', 'p-4', 'bg-blue-500'] ``` ## tw::extractCandidatesFromStrings() ```php public static function extractCandidatesFromStrings(string $source): array ``` Izlušči kandidate za imena razredov iz vseh nizov v enojnih ali dvojnih narekovajih v izvorni kodi, za predloge, ki sezname razredov sestavljajo v spremenljivkah namesto v atributih `class`. Vsak niz razdeli po presledkih in ohrani vsak žeton, ki je videti kot ime razreda. **Vrne** `array`. ```php use TailwindPHP\tw; $classes = tw::extractCandidatesFromStrings(''); // ['p-4', 'sm:flex', 'hello', 'world'] $css = tw::compile()->css($classes); ``` Preverjanje uspe tudi za navadne besede (zgornja `hello` in `world`); ne ustvarijo ničesar, razen če so imena pripomočkov. Rezultat posredujte funkciji [`css()`](#tailwindcompiler-instance-methods), saj `generate()` bere samo atribute `class`. ## tw::cssMap() ```php public static function cssMap(string $css = '@import "tailwindcss";'): array ``` Iz deklaracij CSS ustvari obratno preslikavo v razrede pripomočkov, uporabno za pretvorbo obstoječih CSS v razrede Tailwind. Ključi so nizi `"property: value"` z razrešenimi spremenljivkami (pripomočki z več lastnostmi dobijo tudi ključ `"prop: value; prop: value"`), vrednosti pa so imena razredov. **Vrne** `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' ``` Preslikava zajema določen seznam pogostih pripomočkov (prikaz, položaj, flexbox, tipografija, koraki za razmik in velikost, obrobe, črne, bele in prosojne barve ter podobno), ne pa vseh pripomočkov ali barv teme. Argument `$css` spremeni razrešene vrednosti teh pripomočkov, vendar žetoni teme po meri (na primer `--color-brand`) ne dodajo novih vnosov. ## tw::minify() ```php public static function minify(string $css): string ``` Zmanjša poljuben niz CSS: odstrani komentarje, strne presledke, skrajša šestnajstiške barve (`#ffffff` → `#fff`), odstrani enote pri ničelnih vrednostih (`0px` → `0`) in še več. **Vrne** `string`. Za CSS, ki jih TailwindPHP ustvari sam, raje uporabite možnost `minify` (`tw::generate(['minify' => true])`) ali parameter `$minify` v [metodah prevajalnika](#tailwindcompiler-instance-methods). Ta način zmanjša velikost med serializacijo, je hitrejši in ohrani izbirnike potomcev `:not()`, ki jih postopek na podlagi niza strne. ```php use TailwindPHP\tw; $css = tw::generate('
'); $minified = tw::minify($css); ``` Celoten nabor optimizacij najdete v poglavju [Predpomnjenje in zmanjševanje velikosti](https://tailwindphp.inline0.dev/sl/docs/advanced/caching). ## tw::clearCache() ```php public static function clearCache(string|bool|null $cache = true): int ``` Izbriše predpomnjene datoteke CSS. Za privzeti imenik predpomnilnika podajte `true` (ali ne podajte ničesar), za imenik po meri pa niz s potjo. **Vrne** `int` — število izbrisanih datotek. ```php use TailwindPHP\tw; tw::clearCache(); // default directory tw::clearCache('/path/to/cache'); // custom directory ``` Na voljo je tudi samostojna funkcija `TailwindPHP\clearCache()`. ## tw::colors() ```php public static function colors(string $css = '@import "tailwindcss";'): array ``` Vrne vse barvne vrednosti iz teme. **Vrne** `array` (ime barve → izračunana vrednost). ```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 ``` Vrne vse vrednosti prelomnih točk iz teme. **Vrne** `array` (ime prelomne točke → vrednost). ```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 ``` Vrne vrednosti razmikov po meri iz teme. **Vrne** `array` (ime razmika → vrednost). ```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'] ``` ## Vhodne oblike Metode za pregled (`generate`, `properties`, `computedProperties`, `value`, `computedValue`) sprejemajo tri oblike vhoda: | Oblika | Primer | |---|---| | Samo niz | `tw::generate('
')` | | Niz + niz CSS | `tw::generate('
', '@import "tailwindcss"; @theme { ... }')` | | Matrika z `content` (+ neobvezni `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 primerka TailwindCompiler Objekt, ki ga vrne [`tw::compile()`](#twcompile), ponuja enake možnosti pregleda kot statični razred, vezane na CSS, s katerim je bil preveden. Uporabite ga, da se izognete ponovnemu razčlenjevanju teme pri vsakem klicu. ```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 ``` ### Postopno dodajanje ali natančno ustvarjanje `generate()` in `css()` postopoma **dodajata**: vsak klic doda svoje kandidate v naraščajoči nabor prevajalnika, vrnjeni slogovni list pa zajema vse doslej obravnavane kandidate. To je primerno za en slogovni list, ki se sestavlja skozi več predlog. `generateExact()` in `cssExact()` pri vsakem klicu prevedeta **natanko** podano vsebino ali kandidate, brez prenosa med klici, pri tem pa še vedno znova uporabita razčlenjeni sistem zasnove prevajalnika. Izhod je enak tistemu, ki bi ga ustvaril svež `tw::generate()` za isto vsebino. To je najhitrejši način za ustvarjanje slogovnih listov CSS za posamezne strani z enim dolgoživečim prevajalnikom: ```php use TailwindPHP\tw; $compiler = tw::compile($themeCss); foreach ($pages as $slug => $html) { $perPageCss[$slug] = $compiler->generateExact($html, true); } ``` Vse štiri metode sprejemajo neobvezni izbirnik `$minify`, ki med serializacijo ustvari zmanjšan CSS, bajt za bajtom enak `tw::generate(['minify' => true])` in učinkovitejši od naknadnega zmanjševanja oblikovanega izhoda. ### Napredni pregledovalniki Za neposreden pregled prevedenega stanja: ```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 ``` Vrnejo notranje strukture; njihov opis najdete v poglavju [Arhitektura](https://tailwindphp.inline0.dev/sl/docs/advanced/architecture). ### Funkcije nižje ravni Razred `tw` združuje nabor funkcij z imenskimi prostori v `TailwindPHP`. Uporabne so, kadar potrebujete surov rezultat prevajanja namesto `TailwindCompiler`: | Funkcija | Namen | |---|---| | `compile(string $css, array $options = []): array` | Razčleni in prevede CSS. Vrne `build` (postopno dodajanje) in zaključke `buildExact`, ki sprejemajo kandidate in neobvezni izbirnik `$minify`, ter `sources`, `root`, `features` in `designSystem`. Sprejema iste možnosti kot [`tw::compile()`](#twcompile), razen `stateCacheFile` | | `StateCache\compileCssCached(string $css, string $cacheFile, array $options = []): array` | `compile()` z obstojnim [predpomnilnikom stanja prevajalnika](https://tailwindphp.inline0.dev/sl/docs/advanced/caching#compiler-state-cache) | | `parseCssState()`, `finalizeCssState()`, `compileParsed()` | Dve stopnji razčlenjevanja (serializirano stanje in nato iz njega znova zgrajeni zaključki) ter končni korak sestavljanja, ki ga uporablja `compileCssCached()`. `parseCss()` in `compileAst()` ostajata enostopenjski ustreznici | ```php use function TailwindPHP\compile; $compiled = compile('@import "tailwindcss";'); $css = $compiled['build'](['flex', 'p-4'], true); // minified ``` ## Predpomnjenje `tw::generate()` lahko prevedene CSS shrani na disk, da se pri enakih vhodih izogne ponovnemu prevajanju. | Možnost | Vrsta | Privzeto | Namen | |---|---|---|---| | `cache` | `bool \| string` | `false` | `true` omogoči privzeti imenik; niz s potjo uporabi navedeni imenik za predpomnjenje | | `cacheTtl` | `int` | none | Življenjska doba predpomnilnika v sekundah; potekli vnosi se znova prevedejo | ```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 ]); ``` Ključ predpomnilnika se izpelje iz **vsebine**, **konfiguracije CSS** in možnosti **zmanjšanja velikosti**, zato različni vhodi ustvarijo različne datoteke predpomnilnika. Vnose počistite z [`tw::clearCache()`](#twclearcache) ali samostojno funkcijo `TailwindPHP\clearCache()`. Podrobnejši vodnik najdete v poglavju [Predpomnjenje in zmanjševanje velikosti](https://tailwindphp.inline0.dev/sl/docs/advanced/caching).