API

Visa som Markdown Redigera på GitHub Dokumentation på 3843abd

Hela den statiska ytan finns i en klass: TailwindPHP\tw (ett alias för den interna klassen Tailwind). Alla metoder kan anropas statiskt, och inspektionsmetoderna (properties, computedProperties, value, computedValue) accepterar alla de indataformat som beskrivs längst ned på den här sidan.

För återkommande arbete med samma CSS-konfiguration anropar du tw::compile() en gång och återanvänder den returnerade 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

Tolkar innehåll, extraherar klasskandidater och returnerar den genererade CSS. Standardvärdet för $css är @import "tailwindcss";, som inkluderar tema, preflight och utilities. Returnerar 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,
]);

Arrayformen accepterar följande nycklar:

Nyckel	Typ	Syfte
`content`	`string`	Innehåll att genomsöka efter klasskandidater (obligatoriskt)
`css`	`string`	Indata-CSS med Tailwind-direktiv (standardvärde `@import "tailwindcss";`)
`minify`	`bool`	Minimera utdata (standardvärde `false`)
`importPaths`	`string \| array \| callable \| null`	Läs in CSS från filsystemet med fullständig upplösning av `@import` — se Importera CSS
`cache`	`bool \| string`	Aktivera filcache — se Cachning
`cacheTtl`	`int`	Cachens livslängd i sekunder

tw::compile()

PHP

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

Skapar en återanvändbar TailwindCompiler bunden till angiven CSS. Parsning och konstruktion av designsystemet sker en gång, så detta är det effektiva valet när du genererar CSS för många olika innehållssträngar. Använd generate() för att bygga upp en formatmall över flera anrop, eller generateExact() för oberoende utdata per sida. Returnerar 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">');

Arrayen $options accepterar:

Alternativ	Typ	Syfte
`stateCacheFile`	`string`	Sökväg till en PHP-fil som bevarar kompilatorns konstruktionstillstånd mellan begäranden och processer — se Komplilatorns tillståndscache
`polyfills`	`int`	Vilka reservvärden som ska skrivas ut, som en bitmask av `TailwindPHP\POLYFILL_AT_PROPERTY` (`@layer properties`-standardvärdena för `@property`-variabler) och `TailwindPHP\POLYFILL_COLOR_MIX` (statiska färgreservvärden före `color-mix()`). Standardvärde `POLYFILL_ALL`; `POLYFILL_NONE` inaktiverar båda
`importSearchPaths`	`array<string>`	Kataloger att söka i när `@import` löses från filsystemet

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)

Se TailwindCompiler-instansmetoder för en fullständig beskrivning av instansens metoder.

tw::properties()

PHP

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

Returnerar de råa CSS-egenskaperna för en klass, med CSS-variabler olösta. Returnerar array<string, string> (egenskapsnamn → värde).

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

Som properties(), men med varje CSS-variabel löst till ett konkret värde. Returnerar 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

Returnerar det råa värdet för en enskild utility-klass. Returnerar ?string — null om utility-klassen inte hittas.

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

Returnerar det lösta värdet för en enskild utility-klass. Returnerar ?string — null om utility-klassen inte hittas.

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

Extraherar klassnamn från Tailwind-innehåll (läser både attributen class och className). Returnerar 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

Extraherar klassnamnskandidater från varje enkel- eller dubbelciterad sträng i källkoden, för mallar som bygger klasslistor i variabler i stället för i attributen class. Varje sträng delas upp vid blanksteg och varje token som liknar ett klassnamn behålls. Returnerar 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);

Vanliga ord godkänns också (hello, world ovan); de kompileras till ingenting om de inte råkar vara utility-namn. Skicka resultatet till css(), eftersom generate() bara läser class-attribut.

tw::cssMap()

PHP

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

Bygger en omvänd mappning från CSS-deklarationer till utility-klasser, användbar för att konvertera befintlig CSS till Tailwind-klasser. Nycklarna är "property: value"-strängar med lösta variabler (utilities med flera egenskaper får även en "prop: value; prop: value"-nyckel), värdena är klassnamn. Returnerar 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'

Mappningen omfattar en fast lista med vanliga utilities (visning, position, flexbox, typografi, avstånds- och storlekssteg, ramar, svart/vitt/genomskinligt och liknande), inte alla utilities eller temafärger. Argumentet $css ändrar de lösta värdena för dessa utilities, men anpassade temavärden (som --color-brand) lägger inte till några poster.

tw::minify()

PHP

public static function minify(string $css): string

Minimerar en godtycklig CSS-sträng: tar bort kommentarer, komprimerar blanksteg, förkortar hexfärger (#ffffff → #fff), tar bort enheter från nollvärden (0px → 0) med mera. Returnerar string.

För CSS som TailwindPHP genererar själv bör du föredra alternativet minify (tw::generate(['minify' => true])) eller parametern $minify i kompilatormetoderna. Den vägen minimerar vid serialisering, vilket går snabbare och bevarar underordnade :not()-selektorer som den strängbaserade processen slår ihop.

PHP

use TailwindPHP\tw;

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

Se Cachning och minimering för hela uppsättningen optimeringar.

tw::clearCache()

PHP

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

Tar bort cachade CSS-filer. Skicka true (eller utelämna det) för standardcachens katalog, eller en sökvägssträng för en anpassad katalog. Returnerar int — antalet borttagna filer.

PHP

use TailwindPHP\tw;

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

Det finns också en fristående funktion TailwindPHP\clearCache().

tw::colors()

PHP

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

Returnerar alla färgvärden från temat. Returnerar array<string, string> (färgnamn → beräknat värde).

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

Returnerar alla brytpunktsvärden från temat. Returnerar array<string, string> (brytpunktsnamn → värde).

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

Returnerar anpassade avståndsvärden från temat. Returnerar array<string, string> (avståndsnamn → värde).

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

Indataformat

Inspektionsmetoderna (generate, properties, computedProperties, value, computedValue) accepterar tre indatatyper:

Format	Exempel
Endast sträng	`tw::generate('<div class="flex">')`
Sträng + CSS-sträng	`tw::generate('<div class="flex">', '@import "tailwindcss"; @theme { ... }')`
Array med `content` (+ valfritt `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-instansmetoder

Objektet som returneras av tw::compile() har samma inspektionsmetoder som den statiska klassen, bundna till den CSS som det kompilerades med. Använd det för att slippa parsa om temat vid varje anrop.

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

Ackumulerande och exakt generering

generate() och css() ackumulerar: varje anrop lägger till sina kandidater i kompilatorns växande mängd, och den returnerade formatmallen omfattar allt som setts hittills. Det passar för en enda formatmall som byggs upp över flera mallar.

generateExact() och cssExact() kompilerar exakt det angivna innehållet eller kandidaterna vid varje anrop, utan att något förs över mellan anropen, samtidigt som kompilatorns parsade designsystem återanvänds. Utdata motsvarar vad en kall tw::generate() av samma innehåll skulle ge. Det här är det snabbaste sättet att skapa CSS per sida från en långlivad kompilator:

PHP

use TailwindPHP\tw;

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

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

Alla fyra metoder accepterar en valfri $minify-flagga som skriver ut minimerad CSS vid serialisering, byte-identisk med tw::generate(['minify' => true]) och billigare än att minimera den formaterade utdata efteråt.

Avancerade inspektörer

För att granska det kompilerade tillståndet direkt:

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

Dessa returnerar interna strukturer; se Arkitektur för vad de innehåller.

Funktioner på lägre nivå

Klassen tw omsluter en uppsättning funktioner med namnrymder i TailwindPHP. De är användbara när du behöver det råa kompileringsresultatet i stället för en TailwindCompiler:

Funktion	Syfte
`compile(string $css, array $options = []): array`	Parsar och kompilerar CSS. Returnerar `build` (ackumulerande) och `buildExact`-closures som tar kandidater och en valfri `$minify`-flagga, samt `sources`, `root`, `features` och `designSystem`. Accepterar samma alternativ som `tw::compile()` förutom `stateCacheFile`
`StateCache\compileCssCached(string $css, string $cacheFile, array $options = []): array`	`compile()` med den beständiga cachen för kompilatorns tillstånd
`parseCssState()`, `finalizeCssState()`, `compileParsed()`	De två delarna av parsningen (ett serialiserbart tillstånd och därefter closures som återskapas från det) samt det sista sammanfogningssteget som `compileCssCached()` använder. `parseCss()` och `compileAst()` är fortfarande motsvarigheterna i ett enda steg

PHP

use function TailwindPHP\compile;

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

Cachning

tw::generate() kan cacha kompilerad CSS på disk så att identiska indata slipper omkompilering.

Alternativ	Typ	Standardvärde	Syfte
`cache`	`bool \| string`	`false`	`true` aktiverar standardkatalogen; med en sökvägssträng cachas där
`cacheTtl`	`int`	inget	Cachens livslängd i sekunder; utgångna poster kompileras om

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

Cache-nyckeln härleds från innehållet, konfigurationen CSS och alternativet minify, så olika indata ger olika cachefiler. Rensa poster med tw::clearCache() eller den fristående funktionen TailwindPHP\clearCache().

Läs den mer utförliga guiden Cachning och minimering.