API

Prikaži kot Markdown Uredi na GitHub Dokumentacija za 3843abd

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, opisane na dnu te strani.

Pri ponavljajočem delu z isto konfiguracijo CSS enkrat pokličite tw::compile() in znova uporabite vrnjeni TailwindCompiler.

PHP

use TailwindPHP\tw;

$css = tw::generate('<div class="flex items-center p-4 bg-blue-500">');

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('<div class="flex p-4">');

// String with custom CSS
$css = tw::generate('<div class="flex bg-brand">', '@import "tailwindcss"; @theme { --color-brand: #3b82f6; }');

// Array input with options
$css = tw::generate([
    'content' => '<div class="flex p-4">',
    '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
`cache`	`bool \| string`	Omogoči predpomnjenje datotek — glejte Predpomnjenje
`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() 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('<div class="flex p-4 bg-brand">');

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
`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<string>`	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('<div class="bg-red-500/50">');
// .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.

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<string, string> (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(), vendar razreši vsako spremenljivko CSS v konkretno vrednost. Vrne array<string, string>.

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<string>.

PHP

use TailwindPHP\tw;

tw::extractCandidates('<div class="flex p-4" className="bg-blue-500">');
// ['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<string>.

PHP

use TailwindPHP\tw;

$classes = tw::extractCandidatesFromStrings('<?php $wrap = \'p-4 sm:flex\'; $title = "hello world"; ?>');
// ['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(), 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<string, string>.

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. 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('<div class="flex p-4">');
$minified = tw::minify($css);

Celoten nabor optimizacij najdete v poglavju Predpomnjenje in zmanjševanje velikosti.

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<string, string> (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<string, string> (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<string, string> (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('<div class="flex">')`
Niz + niz CSS	`tw::generate('<div class="flex">', '@import "tailwindcss"; @theme { ... }')`
Matrika z `content` (+ neobvezni `css`)	`tw::generate(['content' => '<div class="flex">', '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(), 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('<div class="flex p-4 bg-brand">');
$candidates = $compiler->extractCandidates('<div class="flex p-4 bg-brand">');

$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.

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()`, razen `stateCacheFile`
`StateCache\compileCssCached(string $css, string $cacheFile, array $options = []): array`	`compile()` z obstojnim predpomnilnikom stanja prevajalnika
`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' => '<div class="flex p-4">',
    'cache' => true,
]);

// Custom directory + TTL
$css = tw::generate([
    'content' => '<div class="flex p-4">',
    '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() ali samostojno funkcijo TailwindPHP\clearCache().

Podrobnejši vodnik najdete v poglavju Predpomnjenje in zmanjševanje velikosti.