API

Skatīt kā Markdown Rediģēt vietnē GitHub Dokumentācija vietnē 3843abd

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, 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() un atkārtoti izmantojiet atgriezto 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

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('<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,
]);

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
`cache`	`bool \| string`	Iespējot failu kešatmiņu — skatiet Kešatmiņa
`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() 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('<div class="flex p-4 bg-brand">');

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
`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<string>`	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('<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)

Pilnu instanču metožu klāstu skatiet TailwindCompiler instances metodes.

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<string, string> (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(), bet katrs CSS mainīgais tiek atrisināts līdz konkrētai vērtībai. Atgriež 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

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

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

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(), 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<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'

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

Pilnu optimizāciju sarakstu skatiet sadaļā Kešošana un saspiešana.

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<string, string> (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<string, string> (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<string, string> (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('<div class="flex">')`
Virkne + CSS virkne	`tw::generate('<div class="flex">', '@import "tailwindcss"; @theme { ... }')`
Masīvs ar `content` (+ neobligātu `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";']);

TailwindCompiler instances metodes

Objekts, ko atgriež tw::compile(), 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('<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

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.

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()`, izņemot `stateCacheFile`
`StateCache\compileCssCached(string $css, string $cacheFile, array $options = []): array`	`compile()` ar noturīgo kompilatora stāvokļa kešatmiņu
`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' => '<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
]);

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() vai atsevišķo funkciju TailwindPHP\clearCache().

Plašāku ceļvedi skatiet sadaļā Kešošana un saspiešana.