# API Hela den statiska ytan finns i en klass: `TailwindPHP\tw` (ett alias för den interna klassen `Tailwind`). Alla metoder kan anropas statiskt, och inspektionsmetoderna (`properties`, `computedProperties`, `value`, `computedValue`) accepterar alla de [indataformat](#input-formats) som beskrivs längst ned på den här sidan. För återkommande arbete med samma CSS-konfiguration anropar du [`tw::compile()`](#twcompile) en gång och återanvänder den returnerade [`TailwindCompiler`](#tailwindcompiler-instance-methods). ```php use TailwindPHP\tw; $css = tw::generate('
'); ``` ## tw::generate() ```php public static function generate(string|array $input, string $css = '@import "tailwindcss";'): string ``` Tolkar innehåll, extraherar klasskandidater och returnerar den genererade CSS. Standardvärdet för `$css` är `@import "tailwindcss";`, som inkluderar tema, preflight och utilities. **Returnerar** `string`. ```php use TailwindPHP\tw; // String input $css = tw::generate('
'); // String with custom CSS $css = tw::generate('
', '@import "tailwindcss"; @theme { --color-brand: #3b82f6; }'); // Array input with options $css = tw::generate([ 'content' => '
', 'css' => '@import "tailwindcss";', 'minify' => true, ]); ``` Arrayformen accepterar följande nycklar: | Nyckel | Typ | Syfte | |---|---|---| | `content` | `string` | Innehåll att genomsöka efter klasskandidater (obligatoriskt) | | `css` | `string` | Indata-CSS med Tailwind-direktiv (standardvärde `@import "tailwindcss";`) | | `minify` | `bool` | Minimera utdata (standardvärde `false`) | | `importPaths` | `string \| array \| callable \| null` | Läs in CSS från filsystemet med fullständig upplösning av `@import` — se [Importera CSS](https://tailwindphp.inline0.dev/sv/docs/usage/imports) | | `cache` | `bool \| string` | Aktivera filcache — se [Cachning](#caching) | | `cacheTtl` | `int` | Cachens livslängd i sekunder | ## tw::compile() ```php public static function compile(string $css = '@import "tailwindcss";', array $options = []): TailwindCompiler ``` Skapar en återanvändbar `TailwindCompiler` bunden till angiven CSS. Parsning och konstruktion av designsystemet sker en gång, så detta är det effektiva valet när du genererar CSS för många olika innehållssträngar. Använd `generate()` för att bygga upp en formatmall över flera anrop, eller [`generateExact()`](#accumulating-vs-exact-generation) för oberoende utdata per sida. **Returnerar** `TailwindCompiler`. ```php use TailwindPHP\tw; // Default Tailwind $compiler = tw::compile(); // Custom CSS $compiler = tw::compile('@import "tailwindcss"; @theme { --color-brand: #3b82f6; }'); $css = $compiler->generate('
'); ``` Arrayen `$options` accepterar: | Alternativ | Typ | Syfte | |---|---|---| | `stateCacheFile` | `string` | Sökväg till en PHP-fil som bevarar kompilatorns konstruktionstillstånd mellan begäranden och processer — se [Komplilatorns tillståndscache](https://tailwindphp.inline0.dev/sv/docs/advanced/caching#compiler-state-cache) | | `polyfills` | `int` | Vilka reservvärden som ska skrivas ut, som en bitmask av `TailwindPHP\POLYFILL_AT_PROPERTY` (`@layer properties`-standardvärdena för `@property`-variabler) och `TailwindPHP\POLYFILL_COLOR_MIX` (statiska färgreservvärden före `color-mix()`). Standardvärde `POLYFILL_ALL`; `POLYFILL_NONE` inaktiverar båda | | `importSearchPaths` | `array` | Kataloger att söka i när `@import` löses från filsystemet | ```php use TailwindPHP\tw; use const TailwindPHP\POLYFILL_NONE; // Cache construction state on disk, reused by later requests $compiler = tw::compile('@import "tailwindcss";', [ 'stateCacheFile' => __DIR__ . '/cache/tailwind-state.php', ]); // Plain output without fallbacks, e.g. for CSS modules $compiler = tw::compile('@import "tailwindcss/utilities.css";', [ 'polyfills' => POLYFILL_NONE, ]); $compiler->generate('
'); // .bg-red-500\/50 { background-color: color-mix(in oklab, var(--color-red-500) 50%, transparent); } // (with the default, a `#fb2c3680` fallback comes first and color-mix() moves into @supports) ``` Se [TailwindCompiler-instansmetoder](#tailwindcompiler-instance-methods) för en fullständig beskrivning av instansens metoder. ## tw::properties() ```php public static function properties(string|array $input, string $css = '@import "tailwindcss";'): array ``` Returnerar de **råa** CSS-egenskaperna för en klass, med CSS-variabler olösta. **Returnerar** `array` (egenskapsnamn → värde). ```php use TailwindPHP\tw; tw::properties('p-4'); // ['padding' => 'calc(var(--spacing) * 4)'] tw::properties(['flex', 'items-center', 'p-4']); // ['display' => 'flex', 'align-items' => 'center', 'padding' => 'calc(var(--spacing) * 4)'] ``` ## tw::computedProperties() ```php public static function computedProperties(string|array $input, string $css = '@import "tailwindcss";'): array ``` Som [`properties()`](#twproperties), men med varje CSS-variabel löst till ett konkret värde. **Returnerar** `array`. ```php use TailwindPHP\tw; tw::computedProperties('p-4'); // ['padding' => '1rem'] tw::computedProperties('text-blue-500'); // ['color' => 'oklch(62.3% .214 259.815)'] tw::computedProperties(['flex', 'items-center', 'gap-4']); // ['display' => 'flex', 'align-items' => 'center', 'gap' => '1rem'] ``` ## tw::value() ```php public static function value(string|array $input, string $css = '@import "tailwindcss";'): ?string ``` Returnerar det **råa** värdet för en enskild utility-klass. **Returnerar** `?string` — `null` om utility-klassen inte hittas. ```php use TailwindPHP\tw; tw::value('p-4'); // 'calc(var(--spacing) * 4)' tw::value('text-blue-500'); // 'var(--color-blue-500)' ``` ## tw::computedValue() ```php public static function computedValue(string|array $input, string $css = '@import "tailwindcss";'): ?string ``` Returnerar det **lösta** värdet för en enskild utility-klass. **Returnerar** `?string` — `null` om utility-klassen inte hittas. ```php use TailwindPHP\tw; tw::computedValue('p-4'); // '1rem' tw::computedValue('text-blue-500'); // 'oklch(62.3% .214 259.815)' tw::computedValue('gap-4'); // '1rem' ``` ## tw::extractCandidates() ```php public static function extractCandidates(string $html): array ``` Extraherar klassnamn från Tailwind-innehåll (läser både attributen `class` och `className`). **Returnerar** `array`. ```php use TailwindPHP\tw; tw::extractCandidates('
'); // ['flex', 'p-4', 'bg-blue-500'] ``` ## tw::extractCandidatesFromStrings() ```php public static function extractCandidatesFromStrings(string $source): array ``` Extraherar klassnamnskandidater från varje enkel- eller dubbelciterad sträng i källkoden, för mallar som bygger klasslistor i variabler i stället för i attributen `class`. Varje sträng delas upp vid blanksteg och varje token som liknar ett klassnamn behålls. **Returnerar** `array`. ```php use TailwindPHP\tw; $classes = tw::extractCandidatesFromStrings(''); // ['p-4', 'sm:flex', 'hello', 'world'] $css = tw::compile()->css($classes); ``` Vanliga ord godkänns också (`hello`, `world` ovan); de kompileras till ingenting om de inte råkar vara utility-namn. Skicka resultatet till [`css()`](#tailwindcompiler-instance-methods), eftersom `generate()` bara läser `class`-attribut. ## tw::cssMap() ```php public static function cssMap(string $css = '@import "tailwindcss";'): array ``` Bygger en omvänd mappning från CSS-deklarationer till utility-klasser, användbar för att konvertera befintlig CSS till Tailwind-klasser. Nycklarna är `"property: value"`-strängar med lösta variabler (utilities med flera egenskaper får även en `"prop: value; prop: value"`-nyckel), värdena är klassnamn. **Returnerar** `array`. ```php use TailwindPHP\tw; $map = tw::cssMap(); $map['display: flex']; // 'flex' $map['padding: 1rem']; // 'p-4' $map['text-align: center']; // 'text-center' $map['color: #fff']; // 'text-white' ``` Mappningen omfattar en fast lista med vanliga utilities (visning, position, flexbox, typografi, avstånds- och storlekssteg, ramar, svart/vitt/genomskinligt och liknande), inte alla utilities eller temafärger. Argumentet `$css` ändrar de lösta värdena för dessa utilities, men anpassade temavärden (som `--color-brand`) lägger inte till några poster. ## tw::minify() ```php public static function minify(string $css): string ``` Minimerar en godtycklig CSS-sträng: tar bort kommentarer, komprimerar blanksteg, förkortar hexfärger (`#ffffff` → `#fff`), tar bort enheter från nollvärden (`0px` → `0`) med mera. **Returnerar** `string`. För CSS som TailwindPHP genererar själv bör du föredra alternativet `minify` (`tw::generate(['minify' => true])`) eller parametern `$minify` i [kompilatormetoderna](#tailwindcompiler-instance-methods). Den vägen minimerar vid serialisering, vilket går snabbare och bevarar underordnade `:not()`-selektorer som den strängbaserade processen slår ihop. ```php use TailwindPHP\tw; $css = tw::generate('
'); $minified = tw::minify($css); ``` Se [Cachning och minimering](https://tailwindphp.inline0.dev/sv/docs/advanced/caching) för hela uppsättningen optimeringar. ## tw::clearCache() ```php public static function clearCache(string|bool|null $cache = true): int ``` Tar bort cachade CSS-filer. Skicka `true` (eller utelämna det) för standardcachens katalog, eller en sökvägssträng för en anpassad katalog. **Returnerar** `int` — antalet borttagna filer. ```php use TailwindPHP\tw; tw::clearCache(); // default directory tw::clearCache('/path/to/cache'); // custom directory ``` Det finns också en fristående funktion `TailwindPHP\clearCache()`. ## tw::colors() ```php public static function colors(string $css = '@import "tailwindcss";'): array ``` Returnerar alla färgvärden från temat. **Returnerar** `array` (färgnamn → beräknat värde). ```php use TailwindPHP\tw; tw::colors(); // ['red-500' => 'oklch(63.7% .237 25.331)', 'blue-500' => 'oklch(62.3% .214 259.815)', ...] // With a custom theme tw::colors('@import "tailwindcss"; @theme { --color-brand: #3b82f6; }'); // [..., 'brand' => '#3b82f6'] ``` ## tw::breakpoints() ```php public static function breakpoints(string $css = '@import "tailwindcss";'): array ``` Returnerar alla brytpunktsvärden från temat. **Returnerar** `array` (brytpunktsnamn → värde). ```php use TailwindPHP\tw; tw::breakpoints(); // ['sm' => '40rem', 'md' => '48rem', 'lg' => '64rem', 'xl' => '80rem', '2xl' => '96rem'] tw::breakpoints('@import "tailwindcss"; @theme { --breakpoint-xs: 20rem; }'); // ['sm' => '40rem', ..., '2xl' => '96rem', 'xs' => '20rem'] ``` ## tw::spacing() ```php public static function spacing(string $css = '@import "tailwindcss";'): array ``` Returnerar anpassade avståndsvärden från temat. **Returnerar** `array` (avståndsnamn → värde). ```php use TailwindPHP\tw; // TailwindCSS 4 uses a single --spacing base value rather than a --spacing-* namespace. // This returns any custom --spacing-* values defined in the theme. tw::spacing('@import "tailwindcss"; @theme { --spacing-huge: 10rem; }'); // ['huge' => '10rem'] ``` ## Indataformat Inspektionsmetoderna (`generate`, `properties`, `computedProperties`, `value`, `computedValue`) accepterar tre indatatyper: | Format | Exempel | |---|---| | Endast sträng | `tw::generate('
')` | | Sträng + CSS-sträng | `tw::generate('
', '@import "tailwindcss"; @theme { ... }')` | | Array med `content` (+ valfritt `css`) | `tw::generate(['content' => '
', 'css' => '@import "tailwindcss";'])` | ```php use TailwindPHP\tw; // Format 1: string only tw::properties('p-4'); // Format 2: string + CSS tw::properties('bg-brand', '@import "tailwindcss"; @theme { --color-brand: #3b82f6; }'); // Format 3: array tw::properties(['content' => 'p-4', 'css' => '@import "tailwindcss";']); ``` ## TailwindCompiler-instansmetoder Objektet som returneras av [`tw::compile()`](#twcompile) har samma inspektionsmetoder som den statiska klassen, bundna till den CSS som det kompilerades med. Använd det för att slippa parsa om temat vid varje anrop. ```php public function generate(string $content, bool $minify = false): string public function css(array $candidates, bool $minify = false): string public function generateExact(string $content, bool $minify = false): string public function cssExact(array $candidates, bool $minify = false): string public function extractCandidates(string $html): array public function extractCandidatesFromStrings(string $source): array public function properties(string|array $utilities): array public function computedProperties(string|array $utilities): array public function value(string $utility): ?string public function computedValue(string $utility): ?string public function minify(string $css): string public function colors(): array public function breakpoints(): array public function spacing(): array ``` ```php use TailwindPHP\tw; $compiler = tw::compile('@import "tailwindcss"; @theme { --color-brand: #3b82f6; }'); $css = $compiler->generate('
'); $candidates = $compiler->extractCandidates('
'); $compiler->properties('bg-brand'); // ['background-color' => 'var(--color-brand)'] $compiler->computedProperties('bg-brand'); // ['background-color' => '#3b82f6'] $compiler->value('bg-brand'); // 'var(--color-brand)' $compiler->computedValue('bg-brand'); // '#3b82f6' $minified = $compiler->minify($css); $compiler->colors(); // all color values $compiler->breakpoints(); // all breakpoint values $compiler->spacing(); // custom spacing values ``` ### Ackumulerande och exakt generering `generate()` och `css()` **ackumulerar**: varje anrop lägger till sina kandidater i kompilatorns växande mängd, och den returnerade formatmallen omfattar allt som setts hittills. Det passar för en enda formatmall som byggs upp över flera mallar. `generateExact()` och `cssExact()` kompilerar **exakt** det angivna innehållet eller kandidaterna vid varje anrop, utan att något förs över mellan anropen, samtidigt som kompilatorns parsade designsystem återanvänds. Utdata motsvarar vad en kall `tw::generate()` av samma innehåll skulle ge. Det här är det snabbaste sättet att skapa CSS per sida från en långlivad kompilator: ```php use TailwindPHP\tw; $compiler = tw::compile($themeCss); foreach ($pages as $slug => $html) { $perPageCss[$slug] = $compiler->generateExact($html, true); } ``` Alla fyra metoder accepterar en valfri `$minify`-flagga som skriver ut minimerad CSS vid serialisering, byte-identisk med `tw::generate(['minify' => true])` och billigare än att minimera den formaterade utdata efteråt. ### Avancerade inspektörer För att granska det kompilerade tillståndet direkt: ```php public function getTheme(): Theme public function getDesignSystem(): object public function getCompiled(): array ``` ```php $compiler->getTheme(); // Theme object with resolved values $compiler->getDesignSystem(); // Design system: utilities, variants, etc. $compiler->getCompiled(); // Raw compiled state array ``` Dessa returnerar interna strukturer; se [Arkitektur](https://tailwindphp.inline0.dev/sv/docs/advanced/architecture) för vad de innehåller. ### Funktioner på lägre nivå Klassen `tw` omsluter en uppsättning funktioner med namnrymder i `TailwindPHP`. De är användbara när du behöver det råa kompileringsresultatet i stället för en `TailwindCompiler`: | Funktion | Syfte | |---|---| | `compile(string $css, array $options = []): array` | Parsar och kompilerar CSS. Returnerar `build` (ackumulerande) och `buildExact`-closures som tar kandidater och en valfri `$minify`-flagga, samt `sources`, `root`, `features` och `designSystem`. Accepterar samma alternativ som [`tw::compile()`](#twcompile) förutom `stateCacheFile` | | `StateCache\compileCssCached(string $css, string $cacheFile, array $options = []): array` | `compile()` med den beständiga [cachen för kompilatorns tillstånd](https://tailwindphp.inline0.dev/sv/docs/advanced/caching#compiler-state-cache) | | `parseCssState()`, `finalizeCssState()`, `compileParsed()` | De två delarna av parsningen (ett serialiserbart tillstånd och därefter closures som återskapas från det) samt det sista sammanfogningssteget som `compileCssCached()` använder. `parseCss()` och `compileAst()` är fortfarande motsvarigheterna i ett enda steg | ```php use function TailwindPHP\compile; $compiled = compile('@import "tailwindcss";'); $css = $compiled['build'](['flex', 'p-4'], true); // minified ``` ## Cachning `tw::generate()` kan cacha kompilerad CSS på disk så att identiska indata slipper omkompilering. | Alternativ | Typ | Standardvärde | Syfte | |---|---|---|---| | `cache` | `bool \| string` | `false` | `true` aktiverar standardkatalogen; med en sökvägssträng cachas där | | `cacheTtl` | `int` | inget | Cachens livslängd i sekunder; utgångna poster kompileras om | ```php use TailwindPHP\tw; // Default directory: sys_get_temp_dir() . '/tailwindphp' $css = tw::generate([ 'content' => '
', 'cache' => true, ]); // Custom directory + TTL $css = tw::generate([ 'content' => '
', 'cache' => '/path/to/cache', 'cacheTtl' => 3600, // expire after 1 hour ]); ``` Cache-nyckeln härleds från **innehållet**, **konfigurationen CSS** och alternativet **minify**, så olika indata ger olika cachefiler. Rensa poster med [`tw::clearCache()`](#twclearcache) eller den fristående funktionen `TailwindPHP\clearCache()`. Läs den mer utförliga guiden [Cachning och minimering](https://tailwindphp.inline0.dev/sv/docs/advanced/caching).