Caching og minificering

Tre hensyn i produktion ligger i udkanten af pipelinen: at undgå genkompilering af identisk input, at undgå omkostningen ved at opbygge en compiler for hver anmodning og at reducere størrelsen af den genererede CSS. Alle tre håndteres af hjælpefunktioner på PHP-siden omkring compileren.

Caching

Generering af CSS kører hele pipelinen ved hvert kald. Når indholdet ikke ændres mellem anmodninger, skriver den filbaserede cache resultatet til disk og leverer det ved efterfølgende kald.

Angiv cache til tw::generate() — true for standardmappen eller en stistreng for en brugerdefineret mappe:

use TailwindPHP\tw;

// Cache to the default directory: sys_get_temp_dir() . '/tailwindphp'
$css = tw::generate([
    'content' => '<div class="flex p-4">Hello</div>',
    'cache' => true,
]);

// Cache to a custom directory
$css = tw::generate([
    'content' => '<div class="flex p-4">Hello</div>',
    'cache' => '/path/to/cache',
]);

// With a time-to-live (seconds)
$css = tw::generate([
    'content' => '<div class="flex p-4">Hello</div>',
    'cache' => true,
    'cacheTtl' => 3600, // expire after 1 hour
]);

Cachemappen oprettes automatisk, hvis den ikke findes.

Cache-nøgle

Nøglen udledes af indholdet, CSS-konfigurationen og flaget minify — og hashes til filnavnet tailwind_<hash>.css. Enhver ændring af markuppen, CSS-inputtet eller om minificering er slået til, giver en anden nøgle og dermed en anden fil.

CSS-konfigurationen i nøglen består af den indlejrede css samt indholdet af filerne, der er angivet i importPaths. To input indgår ikke: filer, der hentes via en indlejret @import i disse filer, og TailwindPHP-versionen. Ryd cachen efter redigering af et indlejret import eller opgradering af pakken, ellers fortsætter det gamle output med at blive leveret.

Levetid

cacheTtl er en levetid i sekunder. Ved et cache-hit sammenlignes filens ændringstidspunkt med det aktuelle tidspunkt; hvis filen er ældre end cacheTtl, behandles det som et cache-miss, og der kompileres igen. Uden cacheTtl udløber posterne aldrig — ryd dem eksplicit.

Rydning af cachen

tw::clearCache() (eller funktionen clearCache()) fjerner tailwind_*.css-filerne fra en cachemappe og returnerer antallet af slettede filer.

use TailwindPHP\tw;
use function TailwindPHP\clearCache;

$deleted = tw::clearCache();                  // default directory
$deleted = tw::clearCache('/path/to/cache');  // custom directory
clearCache('/path/to/cache');                 // function form

Compilerens tilstandscache

Outputcachen hjælper kun, når det samme indhold kommer igen. Når indholdet ændres ved hvert kald, er det dyre trin selve opbygningen af compileren: afklaring af @import "tailwindcss", fortolkning af de medfølgende ressourcer og akkumulering af temaet. Denne fase afhænger kun af inputtet CSS, så den kan gemmes og genbruges.

Angiv stateCacheFile til tw::compile() (eller new TailwindCompiler($css, $options)):

use TailwindPHP\tw;

$compiler = tw::compile($themeCss, [
    'stateCacheFile' => __DIR__ . '/cache/tailwind-state.php',
]);

$css = $compiler->generateExact($html, true);

Ved den første konstruktion skrives tilstanden til den sti som en almindelig PHP-fil, som OPcache kan dele mellem anmodninger; senere konstruktioner indlæser den i stedet for at fortolke på ny. Outputtet er byteidentisk med en compiler uden cache.

• Filen valideres mod et enginefingeraftryk (størrelsen og mtime for TailwindPHPs kilder og ressourcer), en nøgle afledt af inputtet CSS og indstillingerne base og importSearchPaths samt størrelsen og mtime for hver fil, som inputtet importerede. En uoverensstemmelse medfører, at den genopbygges og overskrives, så en opgradering af TailwindPHP eller redigering af en importeret fil ikke kræver manuelle trin.
• Du vælger selv stien: brug én fil pr. særskilt input CSS i en mappe, som webserveren kan skrive til. Skrivninger er atomiske (en midlertidig fil plus rename()).
• Input, der bruger en brugerdefineret importResolver, omgår cachen, fordi resolverens adfærd ikke kan fingeraftrykkes.
• Den samme cache kan bruges omkring det lavere niveau compile()-array API som TailwindPHP\StateCache\compileCssCached($css, $cacheFile, $options).

tw::generate() tager ikke stateCacheFile; den opbygger en ny compiler ved hvert kald. Brug en compilerinstans, når opbygningsomkostningen har betydning.

Minificering

Minificering gør outputtet mindre til produktion. Flaget minify udsender minificeret CSS direkte under serialisering, så det er både den hurtigste og mest præcise metode; tw::minify() kører den strengbaserede minifier (src/_tailwindphp/CssMinifier.php) på en eksisterende CSS-streng:

use TailwindPHP\tw;

// Minify during generation (serializer path, preferred)
$css = tw::generate([
    'content' => '<div class="flex p-4">Hello</div>',
    'minify' => true,
]);

// Or minify an existing string (string-based post-pass)
$css = tw::generate('<div class="flex p-4">Hello</div>');
$minified = tw::minify($css);

De to metoder giver en tilsvarende struktur, men ikke identiske bytes. Serialiseringsmetoden bevarer efterkommernes :not()-selektorer, som strengpasset slår sammen, så foretræk flaget minify til genereret output, og brug tw::minify() til CSS, der kommer som en streng.

Hvad den gør

Begge metoder anvender det samme sæt størrelsesreduktioner:

Den sammenfletter med vilje ikke dublerede selektorer eller kombinerer shorthand-egenskaber — begge dele gør fejlfinding sværere og kan påvirke kaskaden.

CLI: --minify sammenlignet med --optimize

CLI eksponerer serializerens minificeringsmetode via to flag:

# Optimize and minify (smallest output)
tailwindphp -i ./src/app.css -o ./dist/styles.css --minify   # or -m

# Meant to optimize without minifying
tailwindphp -i ./src/app.css -o ./dist/styles.css --optimize

I den aktuelle udgivelse minificerer --optimize også, så begge kommandoer skriver de samme bytes (#9). lightningcss-tilsvarende transformationer køres ved hver build uanset hvad, så almindeligt output (uden flag) er allerede optimeret og letlæseligt.

Se API-referencen for resten af det offentlige API — tw::generate(), tw::compile(), inspektionsmetoder og inputformater.