# API Koko staattinen rajapinta sijaitsee yhdellä luokalla: `TailwindPHP\tw` (sisäisen `Tailwind`-luokan alias). Kaikkia metodeja voi kutsua staattisesti, ja tarkastusmetodit (`properties`, `computedProperties`, `value`, `computedValue`) hyväksyvät [syötemuodot](#input-formats), jotka kuvataan tämän sivun lopussa. Jos käsittelet samaa CSS-määritystä toistuvasti, kutsu [`tw::compile()`](#twcompile) kerran ja käytä palautettua [`TailwindCompiler`](#tailwindcompiler-instance-methods) uudelleen. ```php use TailwindPHP\tw; $css = tw::generate('
'); ``` ## tw::generate() ```php public static function generate(string|array $input, string $css = '@import "tailwindcss";'): string ``` Jäsentää sisällön, poimii luokkaehdokkaat ja palauttaa luodun CSSn. Oletusarvoinen `$css` on `@import "tailwindcss";`, joka ottaa mukaan teeman, esivalmistelut ja apufunktiot. **Palauttaa** arvon `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, ]); ``` Taulukkomuodossa voi käyttää näitä avaimia: | Avain | Tyyppi | Tarkoitus | |---|---|---| | `content` | `string` | Sisältö, josta luokkaehdokkaita etsitään (pakollinen) | | `css` | `string` | Syöte-CSS, jossa on Tailwind-direktiivit (oletus `@import "tailwindcss";`) | | `minify` | `bool` | Pienennä tuloste (oletus `false`) | | `importPaths` | `string \| array \| callable \| null` | Lataa CSS tiedostojärjestelmästä ja ratkaise `@import` kokonaan — katso [CSSn tuonti](https://tailwindphp.inline0.dev/fi/docs/usage/imports) | | `cache` | `bool \| string` | Ota tiedostovälimuisti käyttöön — katso [Välimuisti](#caching) | | `cacheTtl` | `int` | Välimuistin kesto sekunteina | ## tw::compile() ```php public static function compile(string $css = '@import "tailwindcss";', array $options = []): TailwindCompiler ``` Luo uudelleenkäytettävän `TailwindCompiler`n, joka on sidottu annettuun CSSeen. Jäsennys ja suunnittelujärjestelmän muodostus tehdään kerran, joten tämä on tehokas valinta, kun luot CSSa monista eri sisältömerkkijonoista. Käytä `generate()`a kootaksesi yhden tyylitiedoston useiden kutsujen aikana tai [`generateExact()`](#accumulating-vs-exact-generation) sivukohtaiseen itsenäiseen tulosteeseen. **Palauttaa** arvon `TailwindCompiler`. ```php use TailwindPHP\tw; // Default Tailwind $compiler = tw::compile(); // Custom CSS $compiler = tw::compile('@import "tailwindcss"; @theme { --color-brand: #3b82f6; }'); $css = $compiler->generate('
'); ``` `$options`-taulukko hyväksyy seuraavat arvot: | Valinta | Tyyppi | Tarkoitus | |---|---|---| | `stateCacheFile` | `string` | PHP-tiedoston polku; tiedosto säilyttää kääntäjän alustustilan pyyntöjen ja prosessien välillä — katso [Kääntäjän tilavälimuisti](https://tailwindphp.inline0.dev/fi/docs/advanced/caching#compiler-state-cache) | | `polyfills` | `int` | Määrittää tuotettavat varaarvot bittimaskina: `TailwindPHP\POLYFILL_AT_PROPERTY` (`@layer properties` oletukset `@property`-muuttujille) ja `TailwindPHP\POLYFILL_COLOR_MIX` (staattiset värien varaarvot ennen `color-mix()`a). Oletus `POLYFILL_ALL`; `POLYFILL_NONE` poistaa molemmat käytöstä | | `importSearchPaths` | `array` | Hakemistot, joista `@import` etsitään tiedostojärjestelmästä | ```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) ``` Katso täydellinen instanssirajapinta kohdasta [TailwindCompiler-instanssimetodit](#tailwindcompiler-instance-methods). ## tw::properties() ```php public static function properties(string|array $input, string $css = '@import "tailwindcss";'): array ``` Palauttaa luokan CSS-ominaisuudet sellaisinaan, jolloin CSS-muuttujat jäävät ratkaisematta. **Palauttaa** arvon `array` (ominaisuuden nimi → arvo). ```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 ``` Kuten [`properties()`](#twproperties), mutta kaikki CSS-muuttujat ratkaistaan konkreettisiksi arvoiksi. **Palauttaa** arvon `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 ``` Palauttaa yhden apuluokan **raakaversion** arvon. **Palauttaa** `?string` — `null`, jos apuluokkaa ei löydy. ```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 ``` Palauttaa yhden apuluokan **ratkaistun** arvon. **Palauttaa** `?string` — `null`, jos apuluokkaa ei löydy. ```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 ``` Poimii sisällöstä Tailwind-luokkien nimet (lukee sekä `class`- että `className`-attribuutit). **Palauttaa** arvon `array`. ```php use TailwindPHP\tw; tw::extractCandidates('
'); // ['flex', 'p-4', 'bg-blue-500'] ``` ## tw::extractCandidatesFromStrings() ```php public static function extractCandidatesFromStrings(string $source): array ``` Poimii lähdekoodista luokkaehdokkaat jokaisesta yksi- tai kaksinkertaisiin lainausmerkkeihin suljetusta merkkijonosta. Tarkoitettu malleille, jotka kokoavat luokkalistoja muuttujiin `class`-attribuuttien sijaan. Jokainen merkkijono jaetaan välilyöntien kohdalta, ja kaikki luokkanimiltä näyttävät osat säilytetään. **Palauttaa** arvon `array`. ```php use TailwindPHP\tw; $classes = tw::extractCandidatesFromStrings(''); // ['p-4', 'sm:flex', 'hello', 'world'] $css = tw::compile()->css($classes); ``` Myös tavalliset sanat läpäisevät tarkistuksen (yllä `hello`, `world`); ne eivät tuota mitään, elleivät ne satu olemaan apuluokkien nimiä. Välitä tulos kohteeseen [`css()`](#tailwindcompiler-instance-methods), sillä `generate()` lukee vain `class`-attribuutteja. ## tw::cssMap() ```php public static function cssMap(string $css = '@import "tailwindcss";'): array ``` Muodostaa käänteiskartan CSS-määrityksistä apuluokkiin; hyödyllinen, kun olemassa olevia CSS-määrityksiä muunnetaan Tailwind-luokiksi. Avaimet ovat `"property: value"`-merkkijonoja, joiden muuttujat on ratkaistu (moniominaisuuksiset apuluokat saavat myös `"prop: value; prop: value"`-avaimen); arvot ovat luokkanimiä. **Palauttaa** arvon `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' ``` Kartta kattaa kiinteän luettelon yleisiä apuluokkia (näyttö, sijainti, flexbox, typografia, välistys- ja kokovaiheet, reunukset, mustat, valkoiset ja läpinäkyvät värit sekä vastaavat), mutta ei kaikkia apuluokkia tai teeman värejä. `$css`-argumentti muuttaa näiden apuluokkien ratkaistuja arvoja, mutta mukautetut teematunnisteet, kuten `--color-brand`, eivät lisää uusia kohteita. ## tw::minify() ```php public static function minify(string $css): string ``` Pienentää mielivaltaisen CSS-merkkijonon: poistaa kommentit, tiivistää välilyönnit, lyhentää heksavärit (`#ffffff` → `#fff`), poistaa yksiköt nolla-arvoista (`0px` → `0`) ja muuta. **Palauttaa** arvon `string`. Jos käsittelet kohdetta CSS, jonka TailwindPHP luo itse, suosi valintaa `minify` (`tw::generate(['minify' => true])`) tai parametria `$minify` [kääntäjämetodeissa](#tailwindcompiler-instance-methods). Tämä polku pienentää tulosteen sarjoituksen aikana, mikä on nopeampaa ja säilyttää sisäkkäiset `:not()`-valitsimet, jotka merkkijonopohjainen käsittely litistää. ```php use TailwindPHP\tw; $css = tw::generate('
'); $minified = tw::minify($css); ``` Katso kaikki optimoinnit kohdasta [Välimuisti ja pienennys](https://tailwindphp.inline0.dev/fi/docs/advanced/caching). ## tw::clearCache() ```php public static function clearCache(string|bool|null $cache = true): int ``` Poistaa välimuistissa olevat CSS-tiedostot. Määritä `true` tai jätä se pois käyttääksesi oletusvälimuistihakemistoa; mukautetun hakemiston voit määrittää antamalla polkumerkkijonon. **Palauttaa** arvon `int` — poistettujen tiedostojen määrän. ```php use TailwindPHP\tw; tw::clearCache(); // default directory tw::clearCache('/path/to/cache'); // custom directory ``` Käytettävissä on myös itsenäinen `TailwindPHP\clearCache()`-funktio. ## tw::colors() ```php public static function colors(string $css = '@import "tailwindcss";'): array ``` Palauttaa kaikki teeman väriarvot. **Palauttaa** arvon `array` (värin nimi → laskettu arvo). ```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 ``` Palauttaa kaikki teeman taitearvot. **Palauttaa** arvon `array` (taitekohdan nimi → arvo). ```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 ``` Palauttaa teeman mukautetut välistysarvot. **Palauttaa** arvon `array` (välistyksen nimi → arvo). ```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'] ``` ## Syötemuodot Tarkastusmetodit (`generate`, `properties`, `computedProperties`, `value`, `computedValue`) hyväksyvät kolme syötemuotoa: | Muoto | Esimerkki | |---|---| | Pelkkä merkkijono | `tw::generate('
')` | | Merkkijono + CSS-merkkijono | `tw::generate('
', '@import "tailwindcss"; @theme { ... }')` | | Taulukko, jossa `content` (+ valinnainen `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-instanssimetodit [`tw::compile()`](#twcompile) palauttava olio tarjoaa samat tarkastusmetodit kuin staattinen luokka ja käyttää sitä CSSa, jolla se käännettiin. Sen avulla vältät teeman uudelleenjäsennyksen jokaisella kutsulla. ```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 ``` ### Kumulatiivinen ja täsmällinen generointi `generate()` ja `css()` ovat **kumulatiivisia**: jokainen kutsu lisää ehdokkaansa kääntäjän kasvavaan joukkoon, ja palautettu tyylitiedosto kattaa kaikki siihen mennessä nähdyt ehdokkaat. Tämä sopii yhteen tyylitiedostoon, jota kasvatetaan useiden mallien perusteella. `generateExact()` ja `cssExact()` kääntävät kullakin kutsulla **täsmälleen** annetun sisällön tai ehdokkaat ilman aiempien kutsujen vaikutusta, mutta käyttävät silti uudelleen kääntäjän jäsennettyä suunnittelujärjestelmää. Tuloste vastaa sitä, minkä saman sisällön kylmä `tw::generate()` tuottaisi. Tämä on nopein tapa luoda sivukohtaista CSSa yhdellä pitkäikäisellä kääntäjällä: ```php use TailwindPHP\tw; $compiler = tw::compile($themeCss); foreach ($pages as $slug => $html) { $perPageCss[$slug] = $compiler->generateExact($html, true); } ``` Kaikki neljä metodia hyväksyvät valinnaisen `$minify`-lipun, joka tuottaa pienennetyn CSSn sarjoituksen yhteydessä; tulos on tavutasolla identtinen kohteen `tw::generate(['minify' => true])` kanssa ja edullisempi kuin kauniisti muotoillun tulosteen pienentäminen jälkikäteen. ### Edistyneet tarkastajat Käännetyn tilan suoraa tarkastelua varten: ```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 ``` Nämä palauttavat sisäisiä rakenteita; katso niiden sisältö kohdasta [Arkkitehtuuri](https://tailwindphp.inline0.dev/fi/docs/advanced/architecture). ### Alemman tason funktiot Luokka `tw` käärii joukon nimiavaruuteen `TailwindPHP` sijoitettuja funktioita. Niistä on hyötyä, kun tarvitset raakamuotoisen käännöstuloksen `TailwindCompiler`n sijaan: | Funktio | Tarkoitus | |---|---| | `compile(string $css, array $options = []): array` | Jäsentää ja kääntää kohteen CSS. Palauttaa kumulatiiviset `build`- ja ehdokkaita sekä valinnaisen `$minify`-lipun hyväksyvät `buildExact`-sulkeumat sekä kohteet `sources`, `root`, `features` ja `designSystem`. Hyväksyy samat valinnat kuin [`tw::compile()`](#twcompile), pois lukien `stateCacheFile` | | `StateCache\compileCssCached(string $css, string $cacheFile, array $options = []): array` | `compile()` pysyvällä [kääntäjän tilavälimuistilla](https://tailwindphp.inline0.dev/fi/docs/advanced/caching#compiler-state-cache) | | `parseCssState()`, `finalizeCssState()`, `compileParsed()` | Jäsennyksen kaksi vaihetta (sarjoitettava tila, jonka jälkeen siitä uudelleen muodostetut sulkeumat) sekä lopullinen kokoamisvaihe, jota `compileCssCached()` käyttää. `parseCss()` ja `compileAst()` vastaavat edelleen yhden vaiheen toteutuksia | ```php use function TailwindPHP\compile; $compiled = compile('@import "tailwindcss";'); $css = $compiled['build'](['flex', 'p-4'], true); // minified ``` ## Välimuisti `tw::generate()` voi tallentaa käännetyt CSSt levylle, jotta samojen syötteiden uudelleenkääntäminen voidaan ohittaa. | Valinta | Tyyppi | Oletus | Tarkoitus | |---|---|---|---| | `cache` | `bool \| string` | `false` | `true` ottaa käyttöön oletushakemiston; polkumerkkijono määrittää tallennushakemiston | | `cacheTtl` | `int` | ei mitään | Välimuistin kesto sekunteina; vanhentuneet merkinnät käännetään uudelleen | ```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 ]); ``` Välimuistiavain johdetaan **sisällöstä**, **CSS-määrityksestä** ja **pienennys**-valinnasta, joten eri syötteet tuottavat eri välimuistitiedostot. Tyhjennä merkinnät kohteella [`tw::clearCache()`](#twclearcache) tai itsenäisellä `TailwindPHP\clearCache()`-funktiolla. Katso tarkempi opas kohdasta [Välimuisti ja pienennys](https://tailwindphp.inline0.dev/fi/docs/advanced/caching).