API

Vaata Markdownina Muuda teenuses GitHub Dokumentatsioon: 3843abd

Kogu staatiline liides asub ühes klassis: TailwindPHP\tw (sisemise klassi Tailwind alias). Iga meetodit saab kutsuda staatiliselt ning kontrollimeetodid (properties, computedProperties, value, computedValue) aktsepteerivad kõik sisendvorminguid, mida on kirjeldatud selle lehe lõpus.

Kui töötled korduvalt sama CSS-i seadistusega, kutsu tw::compile() üks kord ja kasuta tagastatud TailwindCompiler korduvalt.

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

Parsib sisu, eraldab klassikandidaadid ja tagastab genereeritud CSS-i. Vaikimisi $css on @import "tailwindcss";, mis kaasab teema, eelseadistuse ja utiliidid. Tagastab 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,
]);

Massiivi kujul saab kasutada järgmisi võtmeid:

Võti	Tüüp	Eesmärk
`content`	`string`	Sisu, kust klassikandidaate otsida (kohustuslik)
`css`	`string`	Sisend-CSS koos Tailwind direktiividega (vaikimisi `@import "tailwindcss";`)
`minify`	`bool`	Minimeeri väljund (vaikimisi `false`)
`importPaths`	`string \| array \| callable \| null`	Laadi failisüsteemist CSS koos täieliku `@import` lahendamisega — vt CSS importimine
`cache`	`bool \| string`	Luba failivahemälu — vt Vahemällu salvestamine
`cacheTtl`	`int`	Vahemälu kehtivusaeg sekundites

tw::compile()

PHP

public static function compile(string $css = '@import "tailwindcss";', array $options = []): TailwindCompiler

Loob korduskasutatava TailwindCompiler-i, mis seotakse antud CSS-iga. Parsimine ja kujundussüsteemi loomine toimuvad üks kord, mistõttu on see tõhus valik, kui genereerida CSS-i paljude eri sisutekstide jaoks. Kasuta generate()-i ühe laaditabeli kogumiseks mitme kutse peale või generateExact() eraldi leheväljundi jaoks. Tagastab 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">');

Massiiv $options aktsepteerib järgmisi väärtusi:

Valik	Tüüp	Eesmärk
`stateCacheFile`	`string`	PHP faili tee; sinna salvestatakse kompilaatori loomise olek püsivalt päringute ja protsesside vahel — vt Kompilaatori oleku vahemälu
`polyfills`	`int`	Määrab väljastatavad varuvariandid bitimaskina: `TailwindPHP\POLYFILL_AT_PROPERTY` (`@layer properties` varuvariandid `@property` muutujate jaoks) ja `TailwindPHP\POLYFILL_COLOR_MIX` (staatilised värvide varuvariandid enne `color-mix()`-i). Vaikimisi `POLYFILL_ALL`; `POLYFILL_NONE` keelab mõlemad
`importSearchPaths`	`array<string>`	Kataloogid, kust otsida failisüsteemist lahendatavaid `@import`-e

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)

Täielikku eksemplarimeetodite loendit vaata lehelt TailwindCompileri eksemplarimeetodid.

tw::properties()

PHP

public static function properties(string|array $input, string $css = '@import "tailwindcss";'): array

Tagastab klassi toored CSS omadused, jättes CSS muutujad lahendamata. Tagastab array<string, string> (omaduse nimi → väärtus).

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

Sarnaneb meetodiga properties(), kuid lahendab kõik CSS muutujad konkreetseteks väärtusteks. Tagastab 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

Tagastab ühe utiliidiklassi toorväärtuse. Tagastab ?string — null, kui utiliiti ei leita.

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

Tagastab ühe utiliidiklassi lahendatud väärtuse. Tagastab ?string — null, kui utiliiti ei leita.

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

Eraldab sisust Tailwind klassinimed (loeb nii class kui ka className atribuute). Tagastab 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

Eraldab lähtekoodi igast ühe- või kahekordselt jutumärkides stringist klassinime kandidaadid; see sobib mallidele, mis koostavad klassiloendeid muutujates, mitte class atribuutides. Iga string jagatakse tühikute järgi ja alles jäetakse kõik klassinimena näivad üksused. Tagastab 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);

Kontrolli läbivad ka tavalised sõnad (ülal hello, world); need kompileeritakse tühjaks, kui need pole juhuslikult utiliitide nimed. Anna tulemus edasi meetodile css(), sest generate() loeb ainult class atribuute.

tw::cssMap()

PHP

public static function cssMap(string $css = '@import "tailwindcss";'): array

Koostab CSS deklaratsioonidest pöördkaardi utiliidiklassidele, mis on kasulik olemasoleva CSS teisendamiseks Tailwind klassideks. Võtmed on "property: value" stringid lahendatud muutujatega (mitme omadusega utiliitidel on ka "prop: value; prop: value"-võti), väärtused on klassinimed. Tagastab 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'

Kaart hõlmab kindlat loendit levinud utiliitidest (kuvamine, asukoht, flexbox, tüpograafia, vahe ja suuruse astmed, äärised, mustad/valged/läbipaistvad värvid jm), mitte iga utiliiti ega teemavärvi. Argument $css muudab nende utiliitide lahendatud väärtusi, kuid kohandatud teemamärgendid, nagu --color-brand, uusi kirjeid ei lisa.

tw::minify()

PHP

public static function minify(string $css): string

Minimeerib suvalise CSS stringi: eemaldab kommentaarid, koondab tühimärgid, lühendab kuueteistkümnendvärve (#ffffff → #fff), eemaldab nullväärtustelt ühikud (0px → 0) ja teeb muudki. Tagastab string.

TailwindPHP enda genereeritud CSS puhul eelista valikut minify (tw::generate(['minify' => true])) või $minify parameetrit kompilaatori meetodites. See meetod minimeerib jadaerialduse käigus, mis on kiirem ja säilitab järglaste :not()-valijad, mille stringipõhine töötlus kokku surub.

PHP

use TailwindPHP\tw;

$css = tw::generate('<div class="flex p-4">');
$minified = tw::minify($css);

Kõigi optimeerimiste kohta vaata lehte Vahemällu salvestamine ja minimeerimine.

tw::clearCache()

PHP

public static function clearCache(string|bool|null $cache = true): int

Kustutab vahemällu salvestatud CSS failid. Kasuta true (või jäta see ära) vaikimisi vahemälukataloogi jaoks või määra kohandatud kataloogi asukohaks tee stringina. Tagastab int — kustutatud failide arvu.

PHP

use TailwindPHP\tw;

tw::clearCache();                  // default directory
tw::clearCache('/path/to/cache');  // custom directory

Saadaval on ka eraldiseisev funktsioon TailwindPHP\clearCache().

tw::colors()

PHP

public static function colors(string $css = '@import "tailwindcss";'): array

Tagastab kõik teema värviväärtused. Tagastab array<string, string> (värvinimi → arvutatud väärtus).

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

Tagastab kõik teema murdepunktide väärtused. Tagastab array<string, string> (murdepunkti nimi → väärtus).

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

Tagastab teema kohandatud vaheväärtused. Tagastab array<string, string> (vahe nimi → väärtus).

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']

Sisendvormingud

Kontrollimeetodid (generate, properties, computedProperties, value, computedValue) aktsepteerivad kolme sisendkuju:

Vorming	Näide
Ainult string	`tw::generate('<div class="flex">')`
String ja CSS-string	`tw::generate('<div class="flex">', '@import "tailwindcss"; @theme { ... }')`
Massiiv, milles on `content` (+ valikuline `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";']);

TailwindCompileri eksemplarimeetodid

Meetodi tw::compile() tagastatud objekt pakub sama kontrolliliidest nagu staatiline klass ning on seotud CSS-iga, millega see kompileeriti. Kasuta seda, et vältida teema uuesti parsimist igal kutsungil.

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

Koguv ja täpne genereerimine

generate() ja css() koguvad andmeid: iga kutse lisab kandidaadid kompilaatori kasvavasse hulka ja tagastatud laaditabel katab kõik seni nähtud kandidaadid. See sobib ühe laaditabeli loomiseks mitme malli põhjal.

generateExact() ja cssExact() kompileerivad iga kutse korral täpselt antud sisu või kandidaadid, varasemat üle kandmata, kuid kasutavad kompilaatori juba parsitud kujundussüsteemi uuesti. Väljund vastab sellele, mille annaks sama sisu värske tw::generate(). See on kiireim viis koostada ühe pika elueaga kompilaatoriga lehepõhine CSS:

PHP

use TailwindPHP\tw;

$compiler = tw::compile($themeCss);

foreach ($pages as $slug => $html) {
    $perPageCss[$slug] = $compiler->generateExact($html, true);
}

Kõik neli meetodit aktsepteerivad valikulist lippu $minify, mis väljastab jadaerialduse käigus minimeeritud CSS-i. Tulemus on bait-baidilt identne tw::generate(['minify' => true])-iga ning selle kasutamine on odavam kui ilusa väljundi hilisem minimeerimine.

Täpsemad kontrollijad

Kompileeritud oleku otseseks uurimiseks:

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

Need tagastavad sisemisi andmestruktuure; nende sisu kohta vaata lehte Arhitektuur.

Madalama taseme funktsioonid

Klass tw pakib nimeruumiga funktsioonide komplekti moodulis TailwindPHP. Need on kasulikud, kui vajad TailwindCompiler asemel töötlemata kompileerimistulemust:

Funktsioon	Eesmärk
`compile(string $css, array $options = []): array`	Parsib ja kompileerib CSS. Tagastab funktsioonid `build` (koguv) ja `buildExact`, mis aktsepteerivad kandidaate ja valikulist lippu `$minify`, samuti `sources`, `root`, `features` ja `designSystem`. Aktsepteerib samu valikuid mis `tw::compile()`, välja arvatud `stateCacheFile`
`StateCache\compileCssCached(string $css, string $cacheFile, array $options = []): array`	`compile()` koos püsiva kompilaatori oleku vahemäluga
`parseCssState()`, `finalizeCssState()`, `compileParsed()`	Parsimise kaks etappi (serialiseeritav olek, seejärel sellest taastatud funktsioonid) ning lõplik kokkupanek, mida kasutab `compileCssCached()`. `parseCss()` ja `compileAst()` on endiselt ühe sammu vasted

PHP

use function TailwindPHP\compile;

$compiled = compile('@import "tailwindcss";');
$css = $compiled['build'](['flex', 'p-4'], true); // minified

Vahemällu salvestamine

tw::generate() saab salvestada kompileeritud CSS-i kettale, et sama sisendi korral kompileerimine vahele jätta.

Valik	Tüüp	Vaikimisi	Eesmärk
`cache`	`bool \| string`	`false`	Lubab `true` vaikekataloogi; teena antud string määrab vahemälu asukoha
`cacheTtl`	`int`	puudub	Vahemälu kehtivusaeg sekundites; aegunud kirjed kompileeritakse uuesti

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
]);

Vahemälu võti põhineb sisul, CSS-i seadistusel ja valikul minify, mistõttu salvestatakse erinevad sisendid eraldi vahemälufailidesse. Kustuta kirjed meetodiga tw::clearCache() või eraldiseisva funktsiooniga TailwindPHP\clearCache().

Põhjalikuma juhendi leiad lehelt Vahemällu salvestamine ja minimeerimine.