# API Hele den statiske flade findes i én klasse: `TailwindPHP\tw` (et alias for den interne klasse `Tailwind`). Alle metoder kan kaldes statisk, og inspektionsmetoderne (`properties`, `computedProperties`, `value`, `computedValue`) accepterer alle de [inputformater](#input-formats), der er beskrevet nederst på denne side. Ved gentaget arbejde med den samme CSS-konfiguration skal du kalde [`tw::compile()`](#twcompile) én gang og genbruge det returnerede [`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 ``` Parser indhold, udtrækker klassekandidater og returnerer den genererede CSS. Standardindstillingen for `$css` er `@import "tailwindcss";`, som henter tema, preflight og hjælpeklasser. **Returnerer** `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 accepterer disse nøgler: | Nøgle | Type | Formål | |---|---|---| | `content` | `string` | Indhold, der skal scannes for klassekandidater (påkrævet) | | `css` | `string` | Input-CSS med Tailwind-direktiver (standard `@import "tailwindcss";`) | | `minify` | `bool` | Minimer outputtet (standard `false`) | | `importPaths` | `string \| array \| callable \| null` | Indlæs CSS fra filsystemet med fuld `@import`-opløsning — se [Import af CSS](https://tailwindphp.inline0.dev/da/docs/usage/imports) | | `cache` | `bool \| string` | Aktivér filcaching — se [Caching](#caching) | | `cacheTtl` | `int` | Cachelevetid i sekunder | ## tw::compile() ```php public static function compile(string $css = '@import "tailwindcss";', array $options = []): TailwindCompiler ``` Opretter en genanvendelig `TailwindCompiler` bundet til den angivne CSS. Parsing og opbygning af designsystemet sker én gang, så dette er det effektive valg, når der genereres CSS for mange forskellige indholdsstrenge. Brug `generate()` til at samle ét stylesheet på tværs af kald, eller [`generateExact()`](#accumulating-vs-exact-generation) til uafhængigt output pr. side. **Returnerer** `TailwindCompiler`. ```php use TailwindPHP\tw; // Default Tailwind $compiler = tw::compile(); // Custom CSS $compiler = tw::compile('@import "tailwindcss"; @theme { --color-brand: #3b82f6; }'); $css = $compiler->generate('
'); ``` Arrayet `$options` accepterer: | Indstilling | Type | Formål | |---|---|---| | `stateCacheFile` | `string` | Sti til en PHP-fil, der bevarer compilerens opbygningstilstand på tværs af anmodninger og processer — se [Compilerens tilstandscache](https://tailwindphp.inline0.dev/da/docs/advanced/caching#compiler-state-cache) | | `polyfills` | `int` | Hvilke fallbackværdier der skal udsendes, som en bitmaske af `TailwindPHP\POLYFILL_AT_PROPERTY` (`@layer properties` standardværdier for `@property`-variabler) og `TailwindPHP\POLYFILL_COLOR_MIX` (statiske farvefallbackværdier før `color-mix()`). Standard `POLYFILL_ALL`; `POLYFILL_NONE` deaktiverer begge | | `importSearchPaths` | `array` | Mapper, der søges i ved opløsning af `@import` fra 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) for alle instansmetoder. ## tw::properties() ```php public static function properties(string|array $input, string $css = '@import "tailwindcss";'): array ``` Returnerer de **rå** CSS-egenskaber for en klasse, hvor CSS-variabler ikke er opløst. **Returnerer** `array` (egenskabsnavn → værdi). ```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 alle CSS-variabler opløst til konkrete værdier. **Returnerer** `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 ``` Returnerer den **rå** værdi for en enkelt hjælpeklasse. **Returnerer** `?string` — `null`, hvis hjælpeklassen ikke findes. ```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 ``` Returnerer den **opløste** værdi for en enkelt hjælpeklasse. **Returnerer** `?string` — `null`, hvis hjælpeklassen ikke findes. ```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 ``` Udtrækker Tailwind-klassenavne fra indhold (læser både attributterne `class` og `className`). **Returnerer** `array`. ```php use TailwindPHP\tw; tw::extractCandidates('
'); // ['flex', 'p-4', 'bg-blue-500'] ``` ## tw::extractCandidatesFromStrings() ```php public static function extractCandidatesFromStrings(string $source): array ``` Udtrækker klassekandidater fra hver enkelt streng i enkelte eller dobbelte anførselstegn i kildekode, til skabeloner, der opbygger klasselister i variabler i stedet for `class`-attributter. Hver streng opdeles ved mellemrum, og alle elementer, der ligner klassenavne, beholdes. **Returnerer** `array`. ```php use TailwindPHP\tw; $classes = tw::extractCandidatesFromStrings(''); // ['p-4', 'sm:flex', 'hello', 'world'] $css = tw::compile()->css($classes); ``` Almindelige ord består også kontrollen (`hello`, `world` ovenfor); de kompileres ikke til noget, medmindre de tilfældigvis er hjælpeklassenavne. Giv resultatet videre til [`css()`](#tailwindcompiler-instance-methods), da `generate()` kun læser attributterne `class`. ## tw::cssMap() ```php public static function cssMap(string $css = '@import "tailwindcss";'): array ``` Opretter et omvendt opslag fra CSS-deklarationer til hjælpeklasser, som er nyttigt til at konvertere eksisterende CSS til Tailwind-klasser. Nøglerne er `"property: value"`-strenge med opløste variabler (hjælpeklasser med flere egenskaber får også en nøgle af typen `"prop: value; prop: value"`), og værdierne er klassenavne. **Returnerer** `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' ``` Opslaget dækker en fast liste over almindelige hjælpeklasser (display, position, flexbox, typografi, trin for afstand og størrelse, kanter, sort/hvid/gennemsigtig samt lignende), men ikke alle hjælpeklasser eller temafarver. Argumentet `$css` ændrer de opløste værdier for disse hjælpeklasser, men brugerdefinerede temaværdier (som `--color-brand`) tilføjer ikke poster. ## tw::minify() ```php public static function minify(string $css): string ``` Minimerer en vilkårlig CSS-streng: fjerner kommentarer, samler mellemrum, forkorter hex-farver (`#ffffff` → `#fff`), fjerner enheder fra nulværdier (`0px` → `0`) med mere. **Returnerer** `string`. For CSS, som TailwindPHP selv genererer, skal du foretrække indstillingen `minify` (`tw::generate(['minify' => true])`) eller parameteren `$minify` i [compilerens metoder](#tailwindcompiler-instance-methods). Denne fremgangsmåde minimerer under serialisering, hvilket er hurtigere og bevarer efterkommervælgere af typen `:not()`, som den strengbaserede proces slår sammen. ```php use TailwindPHP\tw; $css = tw::generate('
'); $minified = tw::minify($css); ``` Se [Caching og minimering](https://tailwindphp.inline0.dev/da/docs/advanced/caching) for hele sættet af optimeringer. ## tw::clearCache() ```php public static function clearCache(string|bool|null $cache = true): int ``` Sletter cachelagrede CSS-filer. Angiv `true` (eller udelad den) for standardcachemappen eller en stistreng for en brugerdefineret mappe. **Returnerer** `int` — antallet af slettede filer. ```php use TailwindPHP\tw; tw::clearCache(); // default directory tw::clearCache('/path/to/cache'); // custom directory ``` Der findes også en selvstændig funktion af typen `TailwindPHP\clearCache()`. ## tw::colors() ```php public static function colors(string $css = '@import "tailwindcss";'): array ``` Returnerer alle farveværdier fra temaet. **Returnerer** `array` (farvenavn → beregnet værdi). ```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 ``` Returnerer alle brudpunktsværdier fra temaet. **Returnerer** `array` (brudpunktsnavn → værdi). ```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 ``` Returnerer brugerdefinerede afstandsværdier fra temaet. **Returnerer** `array` (afstandens navn → værdi). ```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'] ``` ## Inputformater Inspektionsmetoderne (`generate`, `properties`, `computedProperties`, `value`, `computedValue`) accepterer tre inputformer: | Format | Eksempel | |---|---| | Kun streng | `tw::generate('
')` | | Streng + CSS-streng | `tw::generate('
', '@import "tailwindcss"; @theme { ... }')` | | Array med `content` (+ valgfri `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, der returneres af [`tw::compile()`](#twcompile), har samme inspektionsmetoder som den statiske klasse, bundet til den CSS, det blev kompileret med. Brug det for at undgå at parse temaet igen ved hvert kald. ```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 ``` ### Akkumulerende eller præcis generering `generate()` og `css()` **akkumulerer**: hvert kald føjer sine kandidater til compilerens voksende sæt, og det returnerede stylesheet dækker alt, der hidtil er set. Det passer til ét stylesheet, der opbygges på tværs af skabeloner. `generateExact()` og `cssExact()` kompilerer **præcis** det angivne indhold eller de angivne kandidater ved hvert kald uden at videreføre noget mellem kald, samtidig med at compilerens parsede designsystem genbruges. Outputtet svarer til resultatet af en kold `tw::generate()` med det samme indhold. Dette er den hurtigste måde at opbygge CSS pr. side fra én langlivet compiler: ```php use TailwindPHP\tw; $compiler = tw::compile($themeCss); foreach ($pages as $slug => $html) { $perPageCss[$slug] = $compiler->generateExact($html, true); } ``` Alle fire metoder accepterer et valgfrit `$minify`-flag, der udsender minimeret CSS under serialisering. Resultatet er identisk på byteniveau med `tw::generate(['minify' => true])` og kræver færre ressourcer end at minimere det formaterede output bagefter. ### Avancerede inspektører Til direkte inspektion af den kompilerede tilstand: ```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 ``` Disse returnerer interne strukturer; se [Arkitektur](https://tailwindphp.inline0.dev/da/docs/advanced/architecture) for at få mere at vide om deres indhold. ### Funktioner på lavere niveau Klassen `tw` indkapsler et sæt navnerumsinddelte funktioner i `TailwindPHP`. De er nyttige, når du har brug for det rå kompileringsresultat i stedet for en `TailwindCompiler`: | Funktion | Formål | |---|---| | `compile(string $css, array $options = []): array` | Parser og kompilerer CSS. Returnerer `build` (akkumulerende) og `buildExact`-closures, der tager kandidater og et valgfrit `$minify`-flag, samt `sources`, `root`, `features` og `designSystem`. Accepterer de samme indstillinger som [`tw::compile()`](#twcompile) med undtagelse af `stateCacheFile` | | `StateCache\compileCssCached(string $css, string $cacheFile, array $options = []): array` | `compile()` med den vedvarende [compilerens tilstandscache](https://tailwindphp.inline0.dev/da/docs/advanced/caching#compiler-state-cache) | | `parseCssState()`, `finalizeCssState()`, `compileParsed()` | De to dele af parsing (en serialiserbar tilstand og derefter de closures, der genopbygges ud fra den) samt det endelige samlingstrin, som `compileCssCached()` bruger. `parseCss()` og `compileAst()` er fortsat ækvivalenterne med ét trin | ```php use function TailwindPHP\compile; $compiled = compile('@import "tailwindcss";'); $css = $compiled['build'](['flex', 'p-4'], true); // minified ``` ## Caching `tw::generate()` kan cache kompilerede CSS på disken, så identiske input springer genkompilering over. | Indstilling | Type | Standard | Formål | |---|---|---|---| | `cache` | `bool \| string` | `false` | `true` aktiverer standardmappen; med en stistreng caches der | | `cacheTtl` | `int` | ingen | Cachelevetid i sekunder; udløbne poster kompileres igen | ```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-nøglen udledes af **indholdet**, **CSS-konfigurationen** og indstillingen for **minimering**, så forskellige input giver forskellige cachefiler. Ryd poster med [`tw::clearCache()`](#twclearcache) eller den selvstændige funktion `TailwindPHP\clearCache()`. Se [Caching og minimering](https://tailwindphp.inline0.dev/da/docs/advanced/caching) for den mere dybdegående vejledning.