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

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

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.

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

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

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

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

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:

| Steg | Effekt |
|------|--------|
| Ta bort kommentarer | Tar bort `/* … */`-block |
| Slå ihop blanksteg | Slår ihop upprepade blanksteg och tar bort dem runt `{ } ; : ,` och selektorkombinatorer |
| Förkorta hex-färger | `#ffffff` → `#fff`, `#aabbcc` → `#abc` |
| Ta bort nollenheter | `0px` → `0` (bevarar tidsvärdena `0s`/`0ms`) |
| Förkorta font-weight | `font-weight:normal` → `400`, `font-weight:bold` → `700` |
| Ta bort tomma regler | Tar bort selektorer med tomma deklarationsblock |

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](https://tailwindphp.inline0.dev/sv/docs/cli) exponerar serializerns minifieringsväg genom två flaggor:

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

I den aktuella versionen minifierar även `--optimize`, så båda kommandona skriver samma byte ([#9](https://github.com/inline0/tailwindphp/issues/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](https://tailwindphp.inline0.dev/sv/docs/api).