Memorare în cache și minificare

Trei preocupări pentru producție apar la capătul pipeline-ului: evitarea recompilării aceleiași intrări, evitarea costului construirii compilatorului la fiecare solicitare și reducerea dimensiunii CSS generat. Toate trei sunt ajutoare PHP din jurul compilatorului.

Memorarea în cache

Generarea CSS rulează întregul pipeline la fiecare apel. Pentru conținutul care nu se schimbă între solicitări, cache-ul bazat pe fișiere scrie rezultatul pe disc și îl servește la apelurile ulterioare.

Transmiteți cache către tw::generate() — true pentru directorul implicit sau un șir cu o cale pentru unul personalizat:

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

Directorul cache este creat automat dacă nu există.

Cheia cache-ului

Cheia este derivată din conținut, configurația CSS și indicatorul minify — acestea sunt hash-uite în numele fișierului tailwind_<hash>.css. Orice modificare a marcajului, a intrării CSS sau a activării minificării produce o cheie diferită și, prin urmare, un alt fișier.

Configurația CSS din cheie este configurația css în linie plus conținutul fișierelor numite în importPaths. Două intrări nu sunt incluse: fișierele importate printr-un @import imbricat în acele fișiere și versiunea TailwindPHP. Goliți cache-ul după editarea unui import imbricat sau după actualizarea pachetului; altfel, rezultatul vechi continuă să fie servit.

Durata de păstrare

cacheTtl este durata de viață în secunde. La accesarea unui fișier din cache, timpul său de modificare este comparat cu timpul curent; dacă fișierul este mai vechi decât cacheTtl, accesarea este considerată ratată, iar conținutul este recompilat. Fără cacheTtl, intrările nu expiră niciodată — ștergeți-le explicit.

Golirea cache-ului

tw::clearCache() (sau funcția clearCache()) elimină fișierele tailwind_*.css dintr-un director cache și returnează numărul de fișiere șterse.

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-ul stării compilatorului

Cache-ul de ieșire este util doar când revine același conținut. Când conținutul se schimbă la fiecare apel, partea costisitoare este construirea compilatorului: rezolvarea @import "tailwindcss", analizarea resurselor incluse și acumularea temei. Această etapă depinde doar de intrarea CSS, așa că poate fi stocată și reutilizată.

Transmiteți stateCacheFile către tw::compile() (sau new TailwindCompiler($css, $options)):

use TailwindPHP\tw;

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

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

La prima construire, starea este scrisă în acea cale ca fișier PHP simplu, pe care OPcache îl poate partaja între solicitări; construirile ulterioare îl încarcă în loc să analizeze din nou. Rezultatul este identic la nivel de octeți cu cel al unui compilator fără cache.

• Fișierul este validat folosind amprenta motorului (dimensiunea și timpul de modificare ale surselor și resurselor TailwindPHP), o cheie derivată din intrarea CSS și opțiunile base și importSearchPaths, precum și dimensiunea și timpul de modificare ale fiecărui fișier importat de intrare. O neconcordanță reconstruiește și rescrie fișierul, așa că actualizarea TailwindPHP sau editarea unui fișier importat nu necesită niciun pas manual.
• Dumneavoastră gestionați calea: folosiți un fișier pentru fiecare intrare CSS distinctă, într-un director în care serverul web poate scrie. Scrierile sunt atomice (un fișier temporar plus rename()).
• Intrările care folosesc un importResolver personalizat ocolesc cache-ul, deoarece comportamentul rezolvatorului nu poate fi amprentat.
• Același cache este disponibil pentru compile() API de nivel inferior, sub forma TailwindPHP\StateCache\compileCssCached($css, $cacheFile, $options).

tw::generate() nu acceptă stateCacheFile; construiește un compilator nou la fiecare apel. Folosiți o instanță de compilator când costul construirii contează.

Minificare

Minificarea reduce dimensiunea rezultatului pentru producție. Indicatorul minify emite direct CSS minificat în timpul serializării, fiind astfel metoda cea mai rapidă și precisă; tw::minify() rulează minificatorul bazat pe șiruri (src/_tailwindphp/CssMinifier.php) asupra unui șir CSS existent:

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

Cele două căi produc o structură echivalentă, dar nu octeți identici. Calea serializerului păstrează selectorii :not() descendenți pe care procesarea șirului îi aplatizează, așa că preferați flagul minify pentru rezultatul generat și rezervați tw::minify() pentru CSS care sosește ca șir.

Ce face

Ambele căi aplică același set de reduceri de dimensiune:

Prin concepție, nu unește selectorii duplicați și nici nu combină proprietățile shorthand — ambele îngreunează depanarea și pot afecta cascada.

CLI: --minify vs --optimize

CLI expune calea de minificare a serializerului prin două flaguri:

# 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

În versiunea actuală, --optimize minifică și el, așa că ambele comenzi scriu aceiași octeți (#9). Transformările echivalente cu lightningcss rulează la fiecare compilare, așadar rezultatul simplu (fără flag) este deja forma optimizată și lizibilă.

Pentru restul API-ului public API — tw::generate(), tw::compile(), metodele de inspecție și formatele de intrare — consultați referința API de referință.