Cachelagring och minifiering

Tre produktionsfrågor uppstår i slutet av pipelinen: att undvika omkompilering av identiska indata, att undvika kostnaden för att bygga en kompilator vid varje begäran och att krympa det genererade CSS. Alla tre hanteras av hjälpfunktioner på PHP-sidan runt kompilatorn.

Cachning

Generering av CSS kör hela pipelinen vid varje anrop. För innehåll som inte ändras mellan förfrågningar skriver den filbaserade cachen resultatet till disk och levererar det vid efterföljande anrop.

Skicka cache till tw::generate() — true för standardkatalogen eller en sökvägssträng för en anpassad katalog:

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

Cachekatalogen skapas automatiskt om den inte finns.

Cache-nyckel

Nyckeln härleds från innehållet, konfigurationen för CSS och flaggan minify — och hashas till filnamnet tailwind_<hash>.css. Varje ändring av markupen, indata för CSS eller minifieringsinställningen ger en annan nyckel och därmed en annan fil.

Konfigurationen för CSS i nyckeln består av inline-css plus innehållet i filerna som anges i importPaths. Två indata ingår inte: filer som hämtas genom en nästlad @import i dessa filer och versionen av TailwindPHP. Rensa cachen efter ändringar i en nästlad import eller efter en uppgradering av paketet, annars fortsätter det gamla resultatet att levereras.

Giltighetstid

cacheTtl är en livslängd i sekunder. Vid en cacheträff jämförs filens ändringstid med aktuell tid; om filen är äldre än cacheTtl räknas det som en miss och den kompileras på nytt. Utan cacheTtl upphör poster aldrig att gälla — rensa dem uttryckligen.

Rensa cachen

tw::clearCache() (eller funktionen clearCache()) tar bort tailwind_*.css-filerna från en cachekatalog och returnerar antalet borttagna 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

Kompilatorns tillståndscache

Utdatakan hjälper bara när samma innehåll återkommer. När innehållet ändras vid varje anrop är den kostsamma delen att bygga själva kompilatorn: lösa @import "tailwindcss", parsa de paketerade resurserna och samla ihop temat. Det steget beror bara på indata-CSS och kan därför lagras och återanvändas.

Skicka stateCacheFile till 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);

Vid den första konstruktionen skrivs tillståndet till den sökvägen som en vanlig PHP-fil som OPcache kan dela mellan förfrågningar; senare konstruktioner läser in den i stället för att parsa igen. Resultatet är byte-identiskt med en kompilator utan cache.

• Filen valideras mot ett motorfingeravtryck (storlek och ändringstid för källor och resurser i TailwindPHP), en nyckel härledd från indata-CSS samt alternativen base och importSearchPaths, och storlek och ändringstid för varje fil som indata importerade. En avvikelse gör att filen byggs om och skrivs på nytt, så en uppgradering av TailwindPHP eller redigering av en importerad fil kräver inga manuella åtgärder.
• Du ansvarar för sökvägen: använd en fil per unik indata-CSS i en katalog som webbservern kan skriva till. Skrivningar är atomiska (en temporärfil plus rename()).
• Indata som använder en anpassad importResolver kringgår cachen eftersom resolverns beteende inte kan fingeravtrycksmätas.
• Samma cache finns också för den lägre nivån compile()-arrayen API som TailwindPHP\StateCache\compileCssCached($css, $cacheFile, $options).

tw::generate() tar inte emot stateCacheFile; den bygger en ny kompilator vid varje anrop. Använd en kompilatorinstans när konstruktionskostnaden spelar roll.

Minifiering

Minifiering krymper utdata för produktion. Flaggan minify genererar minifierad CSS direkt under serialiseringen och är därför både den snabbaste och mest precisa metoden; tw::minify() kör den strängbaserade minifieraren (src/_tailwindphp/CssMinifier.php) på en befintlig CSS-sträng:

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 två vägarna ger en likvärdig struktur men inte identiska byte. Serializer-vägen bevarar underordnade :not()-selektorer som strängpasset slår ihop, så använd helst flaggan minify för genererad utdata och reservera tw::minify() för CSS som kommer in som en sträng.

Vad den gör

Båda vägarna tillämpar samma uppsättning storleksminskningar:

Avsiktligt slår den inte ihop dubblerade selektorer eller kombinerar kortformsegenskaper – båda delarna försvårar felsökning och kan påverka kaskaden.

CLI: --minify jämfört med --optimize

CLI exponerar serializerns minifieringsväg genom två flaggor:

# 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 aktuella versionen minifierar även --optimize, så båda kommandona skriver samma byte (#9). lightningcss-motsvarande transformeringar körs vid varje bygge oavsett, så vanlig utdata (utan flagga) är redan optimerad och lättläst.

För resten av det publika API – tw::generate(), tw::compile(), inspektionsmetoder och indataformat – se referensen för API.