Caching en minificatie

Drie aandachtspunten voor productie spelen aan het einde van de pipeline: voorkomen dat identieke invoer opnieuw wordt gecompileerd, vermijden dat bij elk verzoek een compiler moet worden opgebouwd en de gegenereerde CSS verkleinen. Alle drie worden afgehandeld door hulpfuncties aan de PHP-kant van de compiler.

Caching

Bij het genereren van CSS wordt de volledige pipeline bij elke aanroep uitgevoerd. Voor inhoud die tussen verzoeken niet verandert, schrijft de bestandsgebaseerde cache het resultaat naar schijf en serveert dit bij volgende aanroepen.

Geef cache door aan tw::generate() — true voor de standaardmap, of een pad als tekenreeks voor een aangepaste map:

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

De cachemap wordt automatisch aangemaakt als deze nog niet bestaat.

Cachesleutel

De sleutel wordt afgeleid van de inhoud, de configuratie van CSS en de vlag minify — samen gehasht tot de bestandsnaam tailwind_<hash>.css. Elke wijziging aan de markup, de invoer van CSS of de minificatie-instelling levert een andere sleutel en dus een ander bestand op.

De configuratie van CSS in de sleutel bestaat uit de inline css plus de inhoud van de bestanden die in importPaths worden genoemd. Twee invoerbronnen worden niet meegenomen: bestanden die via een geneste @import in die bestanden worden ingeladen, en de versie van TailwindPHP. Wis de cache na het bewerken van een geneste import of het bijwerken van het pakket, anders blijft de oude uitvoer worden aangeboden.

Geldigheidsduur

cacheTtl is een levensduur in seconden. Bij een cachetreffer wordt de wijzigingsdatum van het bestand vergeleken met de huidige tijd. Is het bestand ouder dan cacheTtl, dan geldt dit als een cachemisser en wordt het opnieuw gecompileerd. Zonder cacheTtl verlopen items nooit — wis ze handmatig.

De cache wissen

tw::clearCache() (of de functie clearCache()) verwijdert de tailwind_*.css-bestanden uit een cachemap en geeft het aantal verwijderde bestanden terug.

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

Cache voor compilerstatus

De uitvoercache helpt alleen als dezelfde inhoud opnieuw wordt aangeboden. Als de inhoud bij elke aanroep verandert, zit de dure stap in het opbouwen van de compiler zelf: @import "tailwindcss" oplossen, de gebundelde resources parsen en het thema samenstellen. Die fase is alleen afhankelijk van de invoer-CSS en kan daarom worden opgeslagen en hergebruikt.

Geef stateCacheFile door aan tw::compile() (of new TailwindCompiler($css, $options)):

use TailwindPHP\tw;

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

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

Bij de eerste constructie wordt de status als een gewoon PHP-bestand naar dat pad geschreven, dat OPcache kan delen tussen verzoeken; latere constructies laden het bestand in plaats van opnieuw te parsen. De uitvoer is byte-identiek aan die van een compiler zonder cache.

• Het bestand wordt gevalideerd aan de hand van een enginevingerafdruk (de grootte en mtime van de bronnen en resources van TailwindPHP), een sleutel afgeleid van de invoer-CSS en de opties base en importSearchPaths, en de grootte en mtime van elk bestand dat de invoer heeft geïmporteerd. Bij een verschil wordt het bestand opnieuw opgebouwd en opgeslagen. Daarom zijn na een upgrade van TailwindPHP of een wijziging aan een geïmporteerd bestand geen handmatige stappen nodig.
• Je beheert het pad zelf: gebruik één bestand per afzonderlijke invoer-CSS in een map waarin de webserver kan schrijven. Schrijfbewerkingen zijn atomair (een tijdelijk bestand plus rename()).
• Invoer met een aangepaste importResolver omzeilt de cache, omdat het gedrag van de resolver niet van een vingerafdruk kan worden voorzien.
• Dezelfde cache is beschikbaar rond de compile()-array op lager niveau API als TailwindPHP\StateCache\compileCssCached($css, $cacheFile, $options).

tw::generate() accepteert geen stateCacheFile; bij elke aanroep bouwt het een nieuwe compiler. Gebruik een compilerinstantie als de constructiekosten van belang zijn.

Minificatie

Minificatie verkleint de uitvoer voor productie. De vlag minify produceert rechtstreeks tijdens het serialiseren geminificeerde CSS, en is daardoor de snelste en nauwkeurigste route. tw::minify() voert de tekenreeksminifier (src/_tailwindphp/CssMinifier.php) uit op een bestaande tekenreeks van CSS:

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 twee routes leveren een vergelijkbare structuur op, maar geen identieke bytes. De serialisatieroute behoudt afstammende :not()-selectors die de tekenreeksbewerking samenvoegt. Gebruik daarom bij voorkeur de vlag minify voor gegenereerde uitvoer en bewaar tw::minify() voor CSS die als tekenreeks binnenkomt.

Wat het doet

Beide routes passen dezelfde reeks verkleiningen toe:

Volgens het ontwerp voegt dit geen dubbele selectors samen en combineert het geen shorthand-eigenschappen — beide bemoeilijken het debuggen en kunnen de cascade beïnvloeden.

CLI: --minify tegenover --optimize

De CLI biedt via twee vlaggen toegang tot het minificatiepad van de serializer:

# 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

In de huidige release minificeert --optimize ook, zodat beide opdrachten dezelfde bytes schrijven (#9). De lightningcss-equivalente transformaties worden bij elke build uitgevoerd, dus gewone uitvoer (zonder vlag) is al geoptimaliseerd en leesbaar.

Zie de API-referentie voor de rest van de openbare API: tw::generate(), tw::compile(), inspectiemethoden en invoerformaten.