Ukládání do mezipaměti a minifikace

Tři produkční úlohy stojí na konci procesu: vyhnout se opětovné kompilaci stejného vstupu, vyhnout se nákladnému sestavování kompilátoru při každém požadavku a zmenšit vygenerované CSS. Všechny tři zajišťují pomocné funkce PHP, které obalují kompilátor.

Ukládání do mezipaměti

Generování CSS při každém volání spouští celý proces. Pokud se obsah mezi požadavky nemění, mezipaměť založená na souborech uloží výsledek na disk a při dalších voláních jej poskytne odtud.

Předejte cache funkci tw::generate() — true pro výchozí adresář nebo řetězec s vlastní cestou:

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

Adresář mezipaměti se automaticky vytvoří, pokud neexistuje.

Klíč mezipaměti

Klíč se odvozuje od obsahu, konfigurace CSS a příznaku minify — vše se zahashuje do názvu souboru tailwind_<hash>.css. Jakákoli změna značek, vstupu CSS nebo zapnutí či vypnutí minifikace vytvoří jiný klíč, a tedy i jiný soubor.

Konfigurace CSS v klíči zahrnuje vložený css a obsah souborů uvedených v importPaths. Dva vstupy v klíči zahrnuté nejsou: soubory načtené vnořeným @import uvnitř těchto souborů a verze TailwindPHP. Po úpravě vnořeného importu nebo aktualizaci balíčku mezipaměť vymažte, jinak se bude dál poskytovat starý výstup.

Doba platnosti

cacheTtl určuje dobu platnosti v sekundách. Při nalezení položky v mezipaměti se porovná čas změny souboru s aktuálním časem; je-li soubor starší než cacheTtl, považuje se za chybějící a znovu se zkompiluje. Bez cacheTtl položky nikdy nevyprší — vymažte je ručně.

Vymazání mezipaměti

tw::clearCache() (nebo funkce clearCache()) odstraní soubory tailwind_*.css z adresáře mezipaměti a vrátí počet smazaných souborů.

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

Mezipaměť stavu kompilátoru

Mezipaměť výstupu pomáhá jen tehdy, když se opakuje stejný obsah. Pokud se obsah při každém volání mění, náročná část spočívá v sestavení samotného kompilátoru: vyhodnocení @import "tailwindcss", parsování přibalených zdrojů a sestavení motivu. Tato fáze závisí pouze na vstupu CSS, takže ji lze uložit a znovu použít.

Předejte stateCacheFile funkci tw::compile() (nebo new TailwindCompiler($css, $options)):

use TailwindPHP\tw;

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

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

Při prvním vytvoření se stav zapíše na danou cestu jako prostý soubor PHP, který může OPcache sdílet mezi požadavky; při dalších vytvořeních se načte místo nového parsování. Výstup je bajtově totožný s výstupem kompilátoru bez mezipaměti.

• Soubor se ověřuje podle otisku enginu (velikosti a času poslední změny zdrojů a prostředků TailwindPHP), klíče odvozeného ze vstupu CSS a voleb base a importSearchPaths a velikosti a času poslední změny každého souboru importovaného vstupem. Při neshodě se znovu sestaví a přepíše, takže upgrade TailwindPHP nebo úprava importovaného souboru nevyžaduje ruční zásah.
• Cestu určujete vy: použijte jeden soubor pro každý odlišný vstup CSS v adresáři, do kterého může webový server zapisovat. Zápisy jsou atomické (dočasný soubor plus rename()).
• Vstupy používající vlastní importResolver obcházejí mezipaměť, protože chování resolveru nelze otisknout.
• Stejná mezipaměť je dostupná také kolem nízkoúrovňového pole compile() API jako TailwindPHP\StateCache\compileCssCached($css, $cacheFile, $options).

tw::generate() nepřijímá stateCacheFile; při každém volání sestaví nový kompilátor. Pokud záleží na nákladech konstrukce, použijte instanci kompilátoru.

Minifikace

Minifikace zmenšuje výstup pro produkční prostředí. Příznak minify při serializaci přímo vytváří minifikované CSS, což je nejrychlejší a nejpřesnější postup; tw::minify() spouští minifikátor založený na řetězcích (src/_tailwindphp/CssMinifier.php) nad existujícím řetězcem 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);

Obě cesty vytvářejí ekvivalentní strukturu, ale ne totožné bajty. Cesta serializéru zachovává selektory potomků :not(), které řetězcový průchod slučuje, proto pro generovaný výstup upřednostněte příznak minify a tw::minify() používejte pro CSS, které přichází jako řetězec.

Co dělá

Obě cesty používají stejnou sadu zmenšení velikosti:

Záměrně neslučuje duplicitní selektory ani nekombinuje zkrácené vlastnosti — obojí ztěžuje ladění a může ovlivnit kaskádu.

CLI: --minify vs. --optimize

CLI zpřístupňuje cestu minifikace serializéru pomocí dvou příznaků:

# 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

V aktuálním vydání minifikuje také --optimize, takže oba příkazy zapisují stejné bajty (#9). Transformace ekvivalentní lightningcss se při každém sestavení spouštějí tak jako tak, takže běžný výstup (bez příznaku) už má optimalizovanou a čitelnou podobu.

Zbytek veřejného rozhraní API — tw::generate(), tw::compile(), inspekční metody a vstupní formáty — najdete v referenci API.