API

Vis som Markdown Rediger på GitHub Dokumentation hos 3843abd

Hele den statiske flade findes i én klasse: TailwindPHP\tw (et alias for den interne klasse Tailwind). Alle metoder kan kaldes statisk, og inspektionsmetoderne (properties, computedProperties, value, computedValue) accepterer alle de inputformater, der er beskrevet nederst på denne side.

Ved gentaget arbejde med den samme CSS-konfiguration skal du kalde tw::compile() én gang og genbruge det returnerede 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

Parser indhold, udtrækker klassekandidater og returnerer den genererede CSS. Standardindstillingen for $css er @import "tailwindcss";, som henter tema, preflight og hjælpeklasser. Returnerer 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 accepterer disse nøgler:

Nøgle	Type	Formål
`content`	`string`	Indhold, der skal scannes for klassekandidater (påkrævet)
`css`	`string`	Input-CSS med Tailwind-direktiver (standard `@import "tailwindcss";`)
`minify`	`bool`	Minimer outputtet (standard `false`)
`importPaths`	`string \| array \| callable \| null`	Indlæs CSS fra filsystemet med fuld `@import`-opløsning — se Import af CSS
`cache`	`bool \| string`	Aktivér filcaching — se Caching
`cacheTtl`	`int`	Cachelevetid i sekunder

tw::compile()

PHP

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

Opretter en genanvendelig TailwindCompiler bundet til den angivne CSS. Parsing og opbygning af designsystemet sker én gang, så dette er det effektive valg, når der genereres CSS for mange forskellige indholdsstrenge. Brug generate() til at samle ét stylesheet på tværs af kald, eller generateExact() til uafhængigt output pr. side. Returnerer 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">');

Arrayet $options accepterer:

Indstilling	Type	Formål
`stateCacheFile`	`string`	Sti til en PHP-fil, der bevarer compilerens opbygningstilstand på tværs af anmodninger og processer — se Compilerens tilstandscache
`polyfills`	`int`	Hvilke fallbackværdier der skal udsendes, som en bitmaske af `TailwindPHP\POLYFILL_AT_PROPERTY` (`@layer properties` standardværdier for `@property`-variabler) og `TailwindPHP\POLYFILL_COLOR_MIX` (statiske farvefallbackværdier før `color-mix()`). Standard `POLYFILL_ALL`; `POLYFILL_NONE` deaktiverer begge
`importSearchPaths`	`array<string>`	Mapper, der søges i ved opløsning af `@import` fra 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 for alle instansmetoder.

tw::properties()

PHP

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

Returnerer de rå CSS-egenskaber for en klasse, hvor CSS-variabler ikke er opløst. Returnerer array<string, string> (egenskabsnavn → værdi).

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 alle CSS-variabler opløst til konkrete værdier. Returnerer 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

Returnerer den rå værdi for en enkelt hjælpeklasse. Returnerer ?string — null, hvis hjælpeklassen ikke findes.

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

Returnerer den opløste værdi for en enkelt hjælpeklasse. Returnerer ?string — null, hvis hjælpeklassen ikke findes.

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

Udtrækker Tailwind-klassenavne fra indhold (læser både attributterne class og className). Returnerer 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

Udtrækker klassekandidater fra hver enkelt streng i enkelte eller dobbelte anførselstegn i kildekode, til skabeloner, der opbygger klasselister i variabler i stedet for class-attributter. Hver streng opdeles ved mellemrum, og alle elementer, der ligner klassenavne, beholdes. Returnerer 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);

Almindelige ord består også kontrollen (hello, world ovenfor); de kompileres ikke til noget, medmindre de tilfældigvis er hjælpeklassenavne. Giv resultatet videre til css(), da generate() kun læser attributterne class.

tw::cssMap()

PHP

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

Opretter et omvendt opslag fra CSS-deklarationer til hjælpeklasser, som er nyttigt til at konvertere eksisterende CSS til Tailwind-klasser. Nøglerne er "property: value"-strenge med opløste variabler (hjælpeklasser med flere egenskaber får også en nøgle af typen "prop: value; prop: value"), og værdierne er klassenavne. Returnerer 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'

Opslaget dækker en fast liste over almindelige hjælpeklasser (display, position, flexbox, typografi, trin for afstand og størrelse, kanter, sort/hvid/gennemsigtig samt lignende), men ikke alle hjælpeklasser eller temafarver. Argumentet $css ændrer de opløste værdier for disse hjælpeklasser, men brugerdefinerede temaværdier (som --color-brand) tilføjer ikke poster.

tw::minify()

PHP

public static function minify(string $css): string

Minimerer en vilkårlig CSS-streng: fjerner kommentarer, samler mellemrum, forkorter hex-farver (#ffffff → #fff), fjerner enheder fra nulværdier (0px → 0) med mere. Returnerer string.

For CSS, som TailwindPHP selv genererer, skal du foretrække indstillingen minify (tw::generate(['minify' => true])) eller parameteren $minify i compilerens metoder. Denne fremgangsmåde minimerer under serialisering, hvilket er hurtigere og bevarer efterkommervælgere af typen :not(), som den strengbaserede proces slår sammen.

PHP

use TailwindPHP\tw;

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

Se Caching og minimering for hele sættet af optimeringer.

tw::clearCache()

PHP

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

Sletter cachelagrede CSS-filer. Angiv true (eller udelad den) for standardcachemappen eller en stistreng for en brugerdefineret mappe. Returnerer int — antallet af slettede filer.

PHP

use TailwindPHP\tw;

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

Der findes også en selvstændig funktion af typen TailwindPHP\clearCache().

tw::colors()

PHP

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

Returnerer alle farveværdier fra temaet. Returnerer array<string, string> (farvenavn → beregnet værdi).

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

Returnerer alle brudpunktsværdier fra temaet. Returnerer array<string, string> (brudpunktsnavn → værdi).

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

Returnerer brugerdefinerede afstandsværdier fra temaet. Returnerer array<string, string> (afstandens navn → værdi).

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

Inputformater

Inspektionsmetoderne (generate, properties, computedProperties, value, computedValue) accepterer tre inputformer:

Format	Eksempel
Kun streng	`tw::generate('<div class="flex">')`
Streng + CSS-streng	`tw::generate('<div class="flex">', '@import "tailwindcss"; @theme { ... }')`
Array med `content` (+ valgfri `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, der returneres af tw::compile(), har samme inspektionsmetoder som den statiske klasse, bundet til den CSS, det blev kompileret med. Brug det for at undgå at parse temaet igen ved hvert kald.

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

Akkumulerende eller præcis generering

generate() og css() akkumulerer: hvert kald føjer sine kandidater til compilerens voksende sæt, og det returnerede stylesheet dækker alt, der hidtil er set. Det passer til ét stylesheet, der opbygges på tværs af skabeloner.

generateExact() og cssExact() kompilerer præcis det angivne indhold eller de angivne kandidater ved hvert kald uden at videreføre noget mellem kald, samtidig med at compilerens parsede designsystem genbruges. Outputtet svarer til resultatet af en kold tw::generate() med det samme indhold. Dette er den hurtigste måde at opbygge CSS pr. side fra én langlivet compiler:

PHP

use TailwindPHP\tw;

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

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

Alle fire metoder accepterer et valgfrit $minify-flag, der udsender minimeret CSS under serialisering. Resultatet er identisk på byteniveau med tw::generate(['minify' => true]) og kræver færre ressourcer end at minimere det formaterede output bagefter.

Avancerede inspektører

Til direkte inspektion af den kompilerede tilstand:

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

Disse returnerer interne strukturer; se Arkitektur for at få mere at vide om deres indhold.

Funktioner på lavere niveau

Klassen tw indkapsler et sæt navnerumsinddelte funktioner i TailwindPHP. De er nyttige, når du har brug for det rå kompileringsresultat i stedet for en TailwindCompiler:

Funktion	Formål
`compile(string $css, array $options = []): array`	Parser og kompilerer CSS. Returnerer `build` (akkumulerende) og `buildExact`-closures, der tager kandidater og et valgfrit `$minify`-flag, samt `sources`, `root`, `features` og `designSystem`. Accepterer de samme indstillinger som `tw::compile()` med undtagelse af `stateCacheFile`
`StateCache\compileCssCached(string $css, string $cacheFile, array $options = []): array`	`compile()` med den vedvarende compilerens tilstandscache
`parseCssState()`, `finalizeCssState()`, `compileParsed()`	De to dele af parsing (en serialiserbar tilstand og derefter de closures, der genopbygges ud fra den) samt det endelige samlingstrin, som `compileCssCached()` bruger. `parseCss()` og `compileAst()` er fortsat ækvivalenterne med ét trin

PHP

use function TailwindPHP\compile;

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

Caching

tw::generate() kan cache kompilerede CSS på disken, så identiske input springer genkompilering over.

Indstilling	Type	Standard	Formål
`cache`	`bool \| string`	`false`	`true` aktiverer standardmappen; med en stistreng caches der
`cacheTtl`	`int`	ingen	Cachelevetid i sekunder; udløbne poster kompileres igen

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-nøglen udledes af indholdet, CSS-konfigurationen og indstillingen for minimering, så forskellige input giver forskellige cachefiler. Ryd poster med tw::clearCache() eller den selvstændige funktion TailwindPHP\clearCache().

Se Caching og minimering for den mere dybdegående vejledning.