# 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:

```php
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.

```php
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)`):

```php
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:

```php
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:

| Etapă | Efect |
|------|--------|
| Elimină comentariile | Elimină blocurile `/* … */` |
| Reduce spațiile albe | Reduce secvențele de spații albe și le elimină din jurul `{ } ; : ,` și al combinatorilor de selectori |
| Scurtează culorile hexazecimale | `#ffffff` → `#fff`, `#aabbcc` → `#abc` |
| Elimină unitățile de la zero | `0px` → `0` (păstrează valorile de timp `0s`/`0ms`) |
| Scurtează font-weight | `font-weight:normal` → `400`, `font-weight:bold` → `700` |
| Elimină regulile goale | Elimină selectorii cu blocuri de declarații goale |

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](https://tailwindphp.inline0.dev/ro/docs/cli) expune calea de minificare a serializerului prin două flaguri:

```bash
# 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](https://github.com/inline0/tailwindphp/issues/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ță](https://tailwindphp.inline0.dev/ro/docs/api).