diff --git a/app/Domain/Cms/Widgets/Types/HeroWidget.php b/app/Domain/Cms/Widgets/Types/HeroWidget.php index 344c074..cdb2291 100644 --- a/app/Domain/Cms/Widgets/Types/HeroWidget.php +++ b/app/Domain/Cms/Widgets/Types/HeroWidget.php @@ -70,9 +70,9 @@ public function narrowBehavior(): string public function heights(): array { return [ - 'compact' => 'Kompakt (mind. 400 px)', - 'normal' => 'Normal (mind. 512 px)', - 'large' => 'Groß (mind. 640 px)', + 'compact' => 'Kompakt (niedriger, 75 % der Standardhöhe)', + 'normal' => 'Standard', + 'large' => 'Großzügig (höher, 130 % der Standardhöhe)', ]; } diff --git a/app/Domain/Cms/Widgets/Types/ImageTextWidget.php b/app/Domain/Cms/Widgets/Types/ImageTextWidget.php index e94ab78..e08162a 100644 --- a/app/Domain/Cms/Widgets/Types/ImageTextWidget.php +++ b/app/Domain/Cms/Widgets/Types/ImageTextWidget.php @@ -73,7 +73,7 @@ public function heights(): array { return [ 'compact' => 'Kompakt (flacheres Bild, engere Abstände)', - 'normal' => 'Normal', + 'normal' => 'Standard', 'spacious' => 'Großzügig (höheres Bild, mehr Abstand)', ]; } diff --git a/app/Domain/Cms/Widgets/WidgetType.php b/app/Domain/Cms/Widgets/WidgetType.php index af84b32..c5ee15b 100644 --- a/app/Domain/Cms/Widgets/WidgetType.php +++ b/app/Domain/Cms/Widgets/WidgetType.php @@ -41,7 +41,7 @@ public function version(): int public const HEIGHTS = [ 'auto' => 'Automatisch', 'compact' => 'Kompakt', - 'normal' => 'Normal', + 'normal' => 'Standard', 'large' => 'Groß', 'spacious' => 'Großzügig', 'fill' => 'Abschnittshöhe füllen', diff --git a/app/Domain/Design/DesignScale.php b/app/Domain/Design/DesignScale.php new file mode 100644 index 0000000..c7d1464 --- /dev/null +++ b/app/Domain/Design/DesignScale.php @@ -0,0 +1,164 @@ + + */ + public const PARAMETERS = [ + 'body' => ['label' => 'Fließtext', 'default' => 17, 'min' => 16, 'max' => 20, 'unit' => 'px', 'group' => 'Schrift', + 'hint' => 'Schriftgröße auf Desktop; auf kleinen Bildschirmen etwa 1 px weniger, nie unter 16 px.', + 'effect' => 'Auch Einleitung, Überschrift 3, kleine Schrift und Schaltflächen folgen daraus.'], + 'h1' => ['label' => 'Überschrift 1', 'default' => 40, 'min' => 30, 'max' => 56, 'unit' => 'px', 'group' => 'Schrift', + 'hint' => 'Seitentitel auf Desktop; schrumpft auf Smartphones auf etwa 70 %.', + 'effect' => 'Muss mindestens 4 px größer sein als Überschrift 2.'], + 'h2' => ['label' => 'Überschrift 2', 'default' => 28, 'min' => 22, 'max' => 40, 'unit' => 'px', 'group' => 'Schrift', + 'hint' => 'Abschnittstitel auf Desktop; auch Titel in Bild und Text, Handlungsaufruf und breiten Karten.', + 'effect' => 'Muss mindestens 6 px größer sein als der Fließtext. Überschrift 3 bleibt darunter.'], + 'display' => ['label' => 'Display-Überschrift (Höchstwert)', 'default' => 52, 'min' => 36, 'max' => 80, 'unit' => 'px', 'group' => 'Schrift', + 'hint' => 'Größter Titel (Einstieg). Wächst mit der Breite des Platzes bis zu diesem Wert.', + 'effect' => 'Mindestens so groß wie Überschrift 1.'], + 'space' => ['label' => 'Basisabstand', 'default' => 8, 'min' => 6, 'max' => 12, 'unit' => 'px', 'group' => 'Abstände', + 'hint' => 'Grundmaß des Abstandsrasters (halber, einfacher, anderthalbfacher bis zwölffacher Wert).', + 'effect' => 'Alle Abstandsstufen der Komponenten und die Abstände zwischen Plätzen im Raster.'], + 'section' => ['label' => 'Abschnittsabstand (Desktop)', 'default' => 48, 'min' => 24, 'max' => 96, 'unit' => 'px', 'group' => 'Abstände', + 'hint' => 'Stufe „Normal“ auf Desktop. „Kompakt“ ist zwei Drittel davon, „Großzügig“ das Anderthalbfache.', + 'effect' => 'Auf Smartphones werden alle Stufen kleiner.'], + 'card_pad' => ['label' => 'Karten-Innenabstand', 'default' => 20, 'min' => 12, 'max' => 32, 'unit' => 'px', 'group' => 'Abstände', + 'hint' => 'Innenabstand von Karten auf Desktop.', + 'effect' => 'Große Flächen (Einstieg, Bild und Text, Handlungsaufruf) verwenden das Ein- bis Zweifache.'], + 'header' => ['label' => 'Höhe der Kopfzeile', 'default' => 80, 'min' => 56, 'max' => 112, 'unit' => 'px', 'group' => 'Rahmen', + 'hint' => 'Kopfzeile im Ausgangszustand auf Desktop. Beim Scrollen und auf Smartphones gilt 80 % davon.', + 'effect' => 'Die Anzeigegröße der Wortmarke folgt daraus; die Wortmarke selbst bleibt unverändert.'], + 'width' => ['label' => 'Maximale Inhaltsbreite', 'default' => 1312, 'min' => 960, 'max' => 1600, 'unit' => 'px', 'group' => 'Rahmen', + 'hint' => 'Breite des Standardrasters; Kopfzeile, Inhalt und Fußbereich fluchten hier. „Breit“ ist etwa 17 % mehr.', + 'effect' => 'Der Lesebereich (44 rem) ist davon unabhängig.'], + 'media' => ['label' => 'Bildhöhe in Bild und Text (Desktop)', 'default' => 320, 'min' => 200, 'max' => 480, 'unit' => 'px', 'group' => 'Medien', + 'hint' => 'Höhe des Bildes neben dem Text in der Variante „Standard“. Kompakt: 75 %, Großzügig: 130 %.', + 'effect' => 'Bestimmt zugleich die Mindesthöhe des Einstiegs (das 1,2-Fache; kompakt und großzügig wie bei Bild und Text).'], + ]; + + /** Gruppen in fester Reihenfolge. */ + public const GROUPS = ['Schrift', 'Abstände', 'Rahmen', 'Medien']; + + /** + * @return array + */ + public static function defaults(): array + { + return array_map(static fn (array $p): int => $p['default'], self::PARAMETERS); + } + + /** Name der CSS-Variable, zum Beispiel card_pad → --ds-card-pad. */ + public static function variable(string $key): string + { + return '--ds-'.str_replace('_', '-', $key); + } + + /** + * Prüft vollständige Eingaben (Zeichenketten aus dem Formular oder Zahlen). Gibt Fehlermeldungen je Schlüssel zurück; + * leer, wenn alles zulässig ist. + * + * @param array $input + * @return array + */ + public static function errors(array $input): array + { + $rules = []; + $messages = []; + $names = []; + + foreach (self::PARAMETERS as $key => $p) { + $rules[$key] = ['required', 'integer', 'min:'.$p['min'], 'max:'.$p['max']]; + $names[$key] = $p['label']; + $messages["$key.required"] = $p['label'].': Bitte einen Wert eintragen.'; + $messages["$key.integer"] = $p['label'].': Bitte eine ganze Zahl in Pixeln eintragen.'; + $messages["$key.min"] = $p['label'].': Der Wert muss mindestens '.$p['min'].' px betragen.'; + $messages["$key.max"] = $p['label'].': Der Wert darf höchstens '.$p['max'].' px betragen.'; + } + + $validator = Validator::make(array_intersect_key($input, self::PARAMETERS), $rules, $messages, $names); + $errors = []; + + foreach ($validator->errors()->messages() as $key => $list) { + $errors[$key] = $list[0]; + } + + if ($errors !== []) { + return $errors; + } + + $v = array_map('intval', array_intersect_key($input, self::PARAMETERS)); + + if ($v['h2'] < $v['body'] + 6) { + $errors['h2'] = 'Überschrift 2 muss mindestens 6 px größer sein als der Fließtext ('.($v['body'] + 6).' px).'; + } + + if ($v['h1'] < $v['h2'] + 4) { + $errors['h1'] = 'Überschrift 1 muss mindestens 4 px größer sein als Überschrift 2 ('.($v['h2'] + 4).' px).'; + } + + if ($v['display'] < $v['h1']) { + $errors['display'] = 'Die Display-Überschrift darf nicht kleiner sein als Überschrift 1 ('.$v['h1'].' px).'; + } + + return $errors; + } + + /** + * Gespeicherte Werte lesen: nur bekannte Schlüssel, ganze Zahlen im zulässigen Bereich und stimmige Reihenfolge. + * Alles andere (fehlende Schlüssel, Fremdes, beschädigte Daten) ergibt die Standardwerte, nie einen Fehler. + * + * @return array + */ + public static function read(mixed $stored): array + { + if (! is_array($stored)) { + return self::defaults(); + } + + $merged = self::defaults(); + + foreach (array_keys(self::PARAMETERS) as $key) { + if (array_key_exists($key, $stored) && (is_int($stored[$key]) || (is_string($stored[$key]) && ctype_digit($stored[$key])))) { + $merged[$key] = (int) $stored[$key]; + } + } + + return self::errors($merged) === [] ? $merged : self::defaults(); + } + + /** + * Inline-Stylesheet mit den abweichenden Basiswerten. Ausgegeben werden ausschließlich geprüfte ganze Zahlen zu + * bekannten Schlüsseln. Ohne Abweichung leer: dann gelten die Standardwerte aus tokens.css. + * + * @param array $values + */ + public static function css(array $values): string + { + $declarations = ''; + + foreach (self::PARAMETERS as $key => $p) { + $value = $values[$key] ?? $p['default']; + + if ($value !== $p['default'] && $value >= $p['min'] && $value <= $p['max']) { + $declarations .= sprintf('%s:%d;', self::variable($key), $value); + } + } + + return $declarations === '' ? '' : ':root{'.$declarations.'}'; + } +} diff --git a/app/Domain/Design/DesignSettings.php b/app/Domain/Design/DesignSettings.php new file mode 100644 index 0000000..72b55b9 --- /dev/null +++ b/app/Domain/Design/DesignSettings.php @@ -0,0 +1,121 @@ +|null */ + private static ?array $memo = null; + + /** + * Wirksame Werte (gespeichert oder Standard). + * + * @return array + */ + public static function values(): array + { + if (self::$memo !== null) { + return self::$memo; + } + + try { + $stored = Cache::rememberForever(self::CACHE_KEY, static function (): array { + $row = SiteSetting::query()->find(self::KEY); + + return $row === null ? [] : (array) $row->value; + }); + + return self::$memo = $stored === [] ? DesignScale::defaults() : DesignScale::read($stored); + } catch (Throwable) { + return self::$memo = DesignScale::defaults(); + } + } + + /** Ob abweichende Werte wirksam sind. */ + public static function isCustomised(): bool + { + return self::values() !== DesignScale::defaults(); + } + + /** + * Speichert vollständige, geprüfte Werte. + * + * @param array $input + * @return array Fehlermeldungen je Schlüssel; leer bei Erfolg + */ + public static function save(array $input, ?User $by = null): array + { + $errors = DesignScale::errors($input); + + if ($errors !== []) { + return $errors; + } + + $ordered = []; + + foreach (array_keys(DesignScale::PARAMETERS) as $key) { + $ordered[$key] = (int) $input[$key]; + } + + SiteSetting::query()->updateOrCreate(['key' => self::KEY], ['value' => $ordered, 'updated_by' => $by?->getKey()]); + self::flush(); + + return []; + } + + /** Standardwerte wiederherstellen: die Zeile entfällt, es gelten wieder die Werte aus tokens.css. */ + public static function reset(): void + { + SiteSetting::query()->whereKey(self::KEY)->delete(); + self::flush(); + } + + /** Zeitpunkt der letzten Speicherung, falls vorhanden. */ + public static function updatedAt(): ?Carbon + { + try { + return SiteSetting::query()->find(self::KEY)?->updated_at; + } catch (Throwable) { + return null; + } + } + + public static function flush(): void + { + self::$memo = null; + + try { + Cache::forget(self::CACHE_KEY); + } catch (Throwable) { + // Der Zwischenspeicher ist nur Beschleunigung. + } + } + + /** + * Stylesheet-Block für Layouts und Vorschauen; nach dem Stylesheet der Website einzufügen, damit er gewinnt. + * Leer, solange keine abweichenden Werte gespeichert sind. + */ + public static function styleTag(): HtmlString + { + $css = DesignScale::css(self::values()); + + return new HtmlString($css === '' ? '' : ''); + } +} diff --git a/app/Domain/Design/SiteSetting.php b/app/Domain/Design/SiteSetting.php new file mode 100644 index 0000000..f63a2bf --- /dev/null +++ b/app/Domain/Design/SiteSetting.php @@ -0,0 +1,31 @@ + $value + * @property int|null $updated_by + */ +class SiteSetting extends Model +{ + protected $table = 'site_settings'; + + protected $primaryKey = 'key'; + + public $incrementing = false; + + protected $keyType = 'string'; + + protected $guarded = []; + + protected function casts(): array + { + return ['value' => 'array']; + } +} diff --git a/app/Filament/Pages/DesignGroessen.php b/app/Filament/Pages/DesignGroessen.php new file mode 100644 index 0000000..dfcfc21 --- /dev/null +++ b/app/Filament/Pages/DesignGroessen.php @@ -0,0 +1,133 @@ + */ + public array $werte = []; + + /** Fehlermeldungen je Basiswert nach dem letzten Speichern. @var array */ + public array $fehler = []; + + /** @var array{aktion: string, argument: int|string|null, titel: string, text: string, label: string, gefahr: bool}|null */ + public ?array $bestaetigung = null; + + public static function canAccess(): bool + { + return auth()->user()?->hasStaffRole(StaffRole::Systemverwalter) === true; + } + + public function mount(): void + { + $this->ladeGespeicherte(); + } + + public function getHeading(): string|Htmlable|null + { + return 'Größen'; + } + + public function getMaxContentWidth(): Width|string|null + { + return Width::SevenExtraLarge; + } + + /** Wirksame Werte der Website (gespeichert oder Standard). @return array */ + public function gespeichert(): array + { + return DesignSettings::values(); + } + + /** Ob die Eingaben vom wirksamen Stand abweichen. */ + public function geaendert(): bool + { + $aktuell = []; + + foreach (array_keys(DesignScale::PARAMETERS) as $key) { + $wert = $this->werte[$key] ?? ''; + $aktuell[$key] = is_string($wert) && ctype_digit($wert) ? (int) $wert : $wert; + } + + return $aktuell !== $this->gespeichert(); + } + + public function speichern(): void + { + $this->fehler = DesignSettings::save($this->werte, auth()->user()); + + if ($this->fehler !== []) { + Notification::make()->danger()->title('Nicht gespeichert')->body('Bitte die markierten Werte korrigieren.')->send(); + + return; + } + + $this->ladeGespeicherte(); + Notification::make()->success()->title('Größen gespeichert')->body('Die Werte gelten jetzt auf der Website und in den CMS-Vorschauen.')->send(); + } + + public function askConfirmation(string $aktion, int|string|null $argument = null): void + { + $this->bestaetigung = match ($aktion) { + 'standard' => ['aktion' => 'standard', 'argument' => null, 'titel' => 'Standardwerte wiederherstellen?', 'text' => 'Die gespeicherten Größen werden entfernt. Website und Vorschauen verwenden sofort wieder die Standardwerte aus dem Designsystem. Offene Eingaben gehen dabei verloren.', 'label' => 'Standardwerte wiederherstellen', 'gefahr' => true], + 'verwerfen' => ['aktion' => 'verwerfen', 'argument' => null, 'titel' => 'Änderungen verwerfen?', 'text' => 'Die Eingaben kehren zum wirksamen Stand zurück. Gespeichert wird dabei nichts.', 'label' => 'Verwerfen', 'gefahr' => true], + default => null, + }; + } + + public function confirmConfirmation(): void + { + $frage = $this->bestaetigung; + $this->bestaetigung = null; + + match ($frage['aktion'] ?? null) { + 'standard' => $this->standardWiederherstellen(), + 'verwerfen' => $this->ladeGespeicherte(), + default => null, + }; + } + + public function cancelConfirmation(): void + { + $this->bestaetigung = null; + } + + private function standardWiederherstellen(): void + { + DesignSettings::reset(); + $this->ladeGespeicherte(); + Notification::make()->success()->title('Standardwerte wiederhergestellt')->body('Website und Vorschauen verwenden wieder die Standardwerte.')->send(); + } + + private function ladeGespeicherte(): void + { + $this->werte = $this->gespeichert(); + $this->fehler = []; + } +} diff --git a/app/Filament/Support/WidgetEditor.php b/app/Filament/Support/WidgetEditor.php index cb0388e..f858346 100644 --- a/app/Filament/Support/WidgetEditor.php +++ b/app/Filament/Support/WidgetEditor.php @@ -7,6 +7,7 @@ use App\Domain\Cms\Widgets\WidgetRegistry; use App\Domain\Cms\Widgets\WidgetRenderer; use App\Domain\Cms\Widgets\WidgetType; +use App\Domain\Design\DesignSettings; use Filament\Actions\Action; use Filament\Forms\Components\Builder; use Filament\Forms\Components\Builder\Block; @@ -474,7 +475,7 @@ public static function renderPreview(string $type, array $state): string public static function previewStylesheets(): string { try { - return app(Vite::class)(['resources/css/app.css'])->toHtml(); + return app(Vite::class)(['resources/css/app.css'])->toHtml().DesignSettings::styleTag()->toHtml(); } catch (Throwable) { return ''; } diff --git a/database/migrations/2026_11_22_100000_create_site_settings.php b/database/migrations/2026_11_22_100000_create_site_settings.php new file mode 100644 index 0000000..840ddc0 --- /dev/null +++ b/database/migrations/2026_11_22_100000_create_site_settings.php @@ -0,0 +1,28 @@ +string('key', 100)->primary(); + $table->json('value'); + $table->foreignId('updated_by')->nullable()->constrained('users')->nullOnDelete(); + $table->timestamps(); + }); + } + + public function down(): void + { + Schema::dropIfExists('site_settings'); + } +}; diff --git a/docker/nginx/default.conf b/docker/nginx/default.conf index ff19498..74c32aa 100644 --- a/docker/nginx/default.conf +++ b/docker/nginx/default.conf @@ -1,3 +1,42 @@ +# Kanonische Adresse: https://lara-und-felix.de. Der Synology-Reverse-Proxy beendet HTTPS und spricht intern HTTP mit +# diesem Container. Das öffentliche Protokoll steht deshalb in X-Forwarded-Proto, der öffentliche Host in +# X-Forwarded-Host (falls die Synology ihn setzt) oder sonst im Host-Header. +# +# Weitergeleitet werden nur normale Seitenaufrufe (GET und HEAD): +# - www.lara-und-felix.de und www.laraundfelix.de (HTTP und HTTPS, Protokoll egal) -> https://lara-und-felix.de +# - http://lara-und-felix.de, aber nur wenn X-Forwarded-Proto ausdrücklich "http" lautet. Fehlt der Header +# (direkter Zugriff, Health-Check auf 127.0.0.1), wird nie weitergeleitet. Das verhindert Schleifen, falls ein +# HTTPS-Aufruf ohne den Header ankommt. +# Ebenfalls nur bei ausdrücklichem X-Forwarded-Proto "http", auf genau diesen drei Hostnamen (lara-und-felix.de, +# www.lara-und-felix.de, www.laraundfelix.de): alle anderen Methoden (POST, PUT, DELETE, ...) enden hier mit 403 und +# erreichen Laravel nicht. Ein 301 wäre für sie falsch (der Client schickte den Inhalt erneut oder als GET), und über +# unverschlüsseltes HTTP sollen keine Eingaben oder Zugangsdaten ankommen. Über HTTPS (zum Beispiel der Stripe-Webhook) +# und ohne X-Forwarded-Proto (direkter Zugriff, Health-Check) ändert sich nichts. +# Nie angefasst werden: die ACME-Prüfung unter /.well-known/acme-challenge/ (jede Methode), dev.laraundfelix.de und +# alles, was nicht in der Liste steht. +# Das Ziel ist fest; Pfad und Query-String bleiben über $request_uri erhalten. +map $http_x_forwarded_host $luf_forwarded_host { + default ""; + "~*^\s*(?[^,\s:]+)" $luf_fh; +} + +map $luf_forwarded_host $luf_public_host { + "" $host; + default $luf_forwarded_host; +} + +# Schlüssel: Methode|X-Forwarded-Proto|öffentlicher Host|Pfad. Die Einträge werden der Reihe nach geprüft, der erste +# Treffer gilt: die ACME-Ausnahme steht vor den Weiterleitungen (1), diese vor der Sperre für andere Methoden (2). +# Die Sperre braucht deshalb keine Methodenliste: GET und HEAD sind in den Zeilen davor bereits entschieden. +map "$request_method|$http_x_forwarded_proto|$luf_public_host|$uri" $luf_canonical_redirect { + default 0; + "~*^[^|]*\|[^|]*\|[^|]*\|/\.well-known/acme-challenge/" 0; + "~*^(GET|HEAD)\|[^|]*\|www\.lara-und-felix\.de\.?\|" 1; + "~*^(GET|HEAD)\|[^|]*\|www\.laraundfelix\.de\.?\|" 1; + "~*^(GET|HEAD)\|\s*http\s*(,[^|]*)?\|lara-und-felix\.de\.?\|" 1; + "~*^[^|]*\|\s*http\s*(,[^|]*)?\|(www\.lara-und-felix|www\.laraundfelix|lara-und-felix)\.de\.?\|" 2; +} + server { listen 80; server_name _; @@ -9,6 +48,14 @@ server { # alte Adresse und antwortet mit 502 – etwa bei einem erneuten Deploy-Lauf nach einer Änderung der Env-Datei. resolver 127.0.0.11 valid=10s ipv6=off; + # Läuft vor der Auswahl der location (Rewrite-Phase des Servers), daher steckt die ACME-Ausnahme in der map oben. + if ($luf_canonical_redirect = 1) { + return 301 https://lara-und-felix.de$request_uri; + } + if ($luf_canonical_redirect = 2) { + return 403; + } + client_max_body_size 2048m; client_body_timeout 3600s; send_timeout 3600s; diff --git a/docs/analysen/website-groessenskala-analyse-2026-11-22.md b/docs/analysen/website-groessenskala-analyse-2026-11-22.md new file mode 100644 index 0000000..cc7c5d6 --- /dev/null +++ b/docs/analysen/website-groessenskala-analyse-2026-11-22.md @@ -0,0 +1,262 @@ +# Website-Designsystem: Analyse und Vorschlag einer kompakteren Größenskala + +Stand: 22.11.2026. Phase 1 (Analyse und Abstimmung); am Berichtsstand wurde nichts am Code, an Inhalten oder an Daten geändert. **Umsetzung:** [ADR-44](../architektur/12_Entscheidungsprotokoll_ADR.md) und `docs/architektur/designsystem.md` §15 (Größenskala mit zehn einstellbaren Basiswerten). Abweichungen der Umsetzung vom Vorschlag: Basisabstand 8 px statt Raster 4 px, Abschnittsabstand 48 px, Bildhöhe in Bild und Text als feste Zielhöhe 320 px, Konfiguration in „Website → Design → Größen“. + +## 0. Kurzfassung + +**Befund.** Die Website ist nicht wegen eines einzelnen zu großen Widgets überdimensioniert, sondern weil drei Größensysteme nebeneinander laufen und alle auf einem großzügigen Maßstab aufsetzen: + +1. die zentralen Tokens in `tokens.css` (Fließtext 18 px, H1 52 px, Abschnittsabstände bis 96 px, Kopfzeile 104 px), +2. die aus dem Brand-UI-Kit übernommenen Premium-Komponenten (`lf-hero`, `lf-bild-text`, `lf-premium-card`) mit eigenen `cqi`-, `rem`- und `px`-Werten, die die Tokens nicht verwenden, +3. feste Mindesthöhen und containerprozentuale Innenabstände (Hero 400/512/640 px, Bild-und-Text-Bild bis 424 px Höhe, Innenabstände bis 5 % der Containerbreite). + +„Kompakt“ ist daher keine Skalierung des Ganzen, sondern an jeder Stelle etwas anderes (Mindesthöhe, Bildformat, Listenlayout, Abstandsstufe) und setzt auf dem großen Maßstab auf. Die Beobachtung, dass eine weitere Verkleinerung einzelner Widgets nicht trägt, bestätigt sich. + +**Wichtigster Nebenbefund.** Der Container ist bei 1440 px nicht zu breit (1312 px, 91 % der Fensterbreite). Der Eindruck bei 67 % Zoom entsteht vertikal: Kopfzeile, Hero, Innenabstände und Abschnittsabstände sind in Summe so hoch, dass bei 1440 × 900 nach der Kopfzeile fast nur der Hero sichtbar ist (zweiter Abschnitt beginnt bei 750 von 900 px). + +**Vorschlag.** Eine kompaktere Skala über die bestehenden Tokens, ohne neue Systeme und ohne Datenänderung: + +- Fließtext 17 px statt 18 px (nie unter 16 px), Überschriften deutlich flacher, ein einziger neuer Token `--text-display` für den Seiteneinstieg, +- Abschnittsabstände etwa 30 % kleiner, Kopfzeile 80 px statt 104 px, +- Premium-Komponenten übernehmen die Schriftgrößen aus den Tokens (mit `cqi` nur als Obergrenze) und verwenden einheitliche Innenabstände und Mindesthöhen je Variante. + +**Erwartung (Messung im Scratchpad-Prototyp, 1440 px, Referenzseite `/praevention-im-alltag`).** Seitenhöhe −17 % (2128 → 1759 px), Hero 512 → 384 px, Kopfzeile 104 → 80 px. Bei 390 px −9 %. Die Soll-Werte liegen damit bewusst zwischen 100 % und 67 % der heutigen Höhen (rund 75–85 %), der Fließtext nur bei rund 94 %. + +**Offene Entscheidungen für Lars** stehen in Abschnitt 7. Die wichtigste: wie hoch das Bild in „Bild und Text“ bleiben darf (im Prototyp mit 358 px weiterhin das höchste Element der Seite). + +--- + +## 1. Ist-Zustand: Wo werden Größen definiert? + +| Ebene | Datei | Inhalt | +|---|---|---| +| Typografie-Tokens | `resources/css/tokens.css` | `--text-body` 17→18 px, `--text-lede` 18→21, `--text-h3` 20→22, `--text-h2` 26→34, `--text-h1` 34→52, `--leading-body` 1,6; `--text-small` 15 px | +| Abstände | `tokens.css` | `--space-1…9` (4–96 px); `--section-space-{compact,normal,large}` = 24→48 / 48→96 / 72→128 px; `--section-gap-*` 12→20 / 20→36 / 32→56 px; `--grid-gap` 20→36 px | +| Breiten | `tokens.css` | `--width-reading` 44 rem, `--width-standard` 82 rem (1312 px), `--width-wide` 96 rem; `--gutter` 16–40 px | +| Kopfzeile | `tokens.css`, `site.css` | 104 px Ausgangszustand ab 75 rem, 72 px kompakt; Logo 60 px, im Ausgangszustand `scale(1.32)` (≈ 79 px) | +| Abschnitte | `sections.css` | Innenabstand oben/unten aus den Stufen, Container `slot` und `section` | +| Grundkomponenten | `components.css` | `.button` erbt Fließtextgröße (18 px), Mindesthöhe 44 px; Karten, Formulare | +| Redaktionelle Karten, Katalogkarten, CTA, FAQ | `widgets.css` | eigene `clamp()`-Werte mit `cqi` für Titel, Innenabstände aus `--space-*` | +| Einstieg, Bild und Text, Premium-Karte | `components/lf-*.css` | aus dem Brand-UI-Kit v1.6/v1.7 übernommen; eigene `rem`-, `px`- und `cqi`-Werte, kaum Tokens | +| Mitgliederbereich | `app.css` (`body.member`) | nutzt die Tokens; **eigene feste Überschriften** (H1 34→52 px, H2 22→27 px) | +| Shop | `components/lf-shop.css` | nutzt `--text-body`, `--text-h3`, `--space-*` | +| Verwaltung | `resources/views/filament/*/styles.blade.php` | eigene `--vw-…`-Tokens, lädt `app.css` nicht | + +Alle Werte sind in `rem`, `px` oder `cqi` angegeben (Wurzelgröße 100 %). Es gibt keine Variable, mit der sich die Gesamtdichte der Website steuern ließe. + +## 2. Messgrundlage und Grenzen + +Gemessen wurde in Edge (headless) an einer lokalen Kopie der Seiten `/`, `/praevention-im-alltag` und `/angebote` der Testinstanz bei 1440 × 900, 1920 × 1080, 768 × 1024 und 390 × 844 (mobil), außerdem als Näherung für 67 % Zoom bei 2149 × 1343 CSS-Pixeln. + +**Grenzen (bitte beachten):** + +- Das HTML wurde von der Testinstanz geladen. CSS wurde aus dem Repository (Stand `develop`, Commit `8b59946`) neu zusammengesetzt, **nicht** aus dem ausgelieferten Bundle. Dass beide übereinstimmen, ist nicht geprüft. +- Die Zertifikatsprüfung der Testinstanz schlug lokal fehl (falscher Zertifikatsname). Sie wurde nicht umgangen. Deshalb fehlen **echte Schriften, Bilder (graue Platzhalter), das Logo und JavaScript**. +- Berechnete Schriftgrößen, Innenabstände und Mindesthöhen sind davon unabhängig und belastbar. **Blockhöhen von Text, Seitenhöhen und die Navigation (im Messlauf stand bei 1440 px „Menü“ statt der Hauptnavigation) hängen von Schrift und JavaScript ab und sind nicht belastbar.** Ob die Navigation auf der echten Instanz bei 1440 px in den Menümodus fällt, ist in Phase 0 zu prüfen. +- Die Prozentwerte der Seitenhöhe sind Näherungen. Die Bildschirmfotos im Scratchpad sind keine Abnahmenachweise. + +## 3. Ursachenanalyse + +### 3.1 Systemische Ursachen + +**S1 – Drei parallele Schriftskalen mit Umkehrungen.** Gemessen bei 1440 px: + +| Ebene | Token-Skala | Komponenten-Skala | +|---|---|---| +| Seitentitel | H1 52 px | Einstieg 70,8–72,6 px (`5,4cqi`, Obergrenze 78 px) | +| Abschnittstitel | H2 34 px | Bild und Text 53,6 px (`4,5cqi`, Obergrenze 53,6 px), Handlungsaufruf 36 px | +| Kartentitel | H3 22 px | Premium-Karte 32 px, Katalogkarte bis 24 px | + +Der Titel in „Bild und Text“ (Überschrift zweiter Ebene) ist mit 53,6 px größer als die Seiten-H1 (52 px). Der Kartentitel der Premium-Karte (32 px) liegt nahe an der H2 des Tokens (34 px). Die Hierarchie trägt nicht über Komponenten hinweg. + +**S2 – Containerprozentuale Innenabstände vergrößern sich mit der Breite.** Einstieg `4,3cqi`/`5cqi` (bis 5 rem), Bild und Text `4cqi` (bis 4,5 rem), Handlungsaufruf `5cqi` (bis 3 rem). Bei 1312 px Containerbreite ergeben sich 52–66 px Innenabstand rundum. Das ist kein bewusster Wert, sondern ein Nebeneffekt der Breite. + +**S3 – Höhe wird über Mindesthöhen und Bildseitenverhältnisse bestimmt, nicht über den Inhalt.** + +- Einstieg: Mindesthöhe 25 / 32 / 40 rem (400 / 512 / 640 px). Auf `/praevention-im-alltag` ist der Einstieg (Markenfläche, normal) 512 px hoch, der Inhalt (Titel, Zeile, Schaltfläche) braucht etwa 300 px. +- Bild und Text, ab 900 px Containerbreite: Bild 4:3 bei 566 px Breite = 424 px Höhe. Das Bild, nicht der Text, bestimmt die Widgethöhe (529 px). +- Premium-Karte: Tafel 140/220 px Mindesthöhe, Bild bis `min(70vh, 640px)`. + +**S4 – Chrome (Kopfzeile, Fuß) ist hoch.** Kopfzeile 104 px im Ausgangszustand (Logo-Skalierung 1,32), danach dauerhaft 72 px klebend (8 % von 900 px). Fußbereich 292 px (Fußlogo 72 px, Innenabstände bis 5 rem + 4,5 rem). + +**S5 – Fließtext 18 px bei Zeilenhöhe 1,6.** Der Wert stammt aus dem Zielkonzept (§7.2, 17 → 18 px), ist zugänglich, aber für Source Sans 3 großzügig. Er wirkt auf alles, was `font: inherit` verwendet (Schaltfläche 18 px, Fußzeilenlinks, Mitgliederbereich). + +**S6 – Keine gemeinsame Bedeutung von „kompakt“.** Im Code: + +| Stelle | Was „kompakt“ bewirkt | +|---|---| +| Einstieg, Höhe | Mindesthöhe 400 statt 512 px, sonst nichts | +| Bild und Text, Höhe | Bild 3:2 statt 4:3, Abstände etwas enger (rechnerisch ≈ 450 statt 529 px) | +| Redaktionelle Karten, Katalogkarten | Layoutvariante „Liste“, keine Größenstufe | +| Abschnittsabstand | 24–48 px statt 48–96 px | +| Premium-Karte, Handlungsaufruf, Fließtext, Überschrift, FAQ | gar keine Größenstufe | + +Das Höhenvokabular (`WidgetType::HEIGHTS`, ADR-38) ist einheitlich, die Umsetzung im CSS nicht. „Kompakt“ spart nur dort, wo eine Mindesthöhe gesetzt ist, und setzt dort auf dem großen Maßstab auf (Einstieg kompakt 400 px entspricht dem vorgeschlagenen „normal“ von 384 px). + +### 3.2 Probleme einzelner Komponenten + +- **Schaltflächen** haben vier Größen: global 18 px (Mindesthöhe 44 px), Einstieg 15,4 px (48 px), Bild und Text 14,2 px (47 px), Premium-Karte 15 px (44 px). +- **Einstieg:** Schlagzeile `5,4cqi` mit Obergrenze 4,9 rem; Beschreibung bis 20,8 px. +- **Bild und Text:** `min-block-size` 14 / 18 / 24 rem, Bild nimmt 49 % der Breite; `.lf-bt__body` hat eigene Schriftgröße (17,9 px) statt Token. +- **Premium-Karte:** Innenabstand `clamp(20px, 4.5cqi, 32px)`, ab 520 px `clamp(22px, 4cqi, 36px)`, Titel bis 32 px. +- **Katalogkarte:** Tafel `min-height` 7 rem (11 rem bei einer Karte). +- **Fußbereich:** `clamp()`-Innenabstände ohne Token. + +### 3.3 Bewusst gestaltet und unbeabsichtigt + +| Bewusst | Unbeabsichtigt | +|---|---| +| Markenfarben, Rundungen, gelbe Akzente, Schattenform | Containerprozentuale Innenabstände (S2) | +| Mindest-Trefferfläche 44 px | Bildhöhe aus Seitenverhältnis × Spaltenbreite (S3) | +| Lesebreite 70 ch, 82-rem-Raster | Kopfzeile 104 px aus Logo × 1,32 (S4) | +| Zwei Zustände der Kopfzeile ohne Layoutsprung | Abweichende Schaltflächengrößen, Titel größer als H1 (S1) | + +### 3.4 Was zentral vereinheitlicht werden sollte + +Schriftstufen für Titel (Display, H1–H3), Fließtext, Schaltflächen; Innenabstand von Flächen (Karte, Einstieg, Bild und Text, Handlungsaufruf); Mindesthöhen je Stufe (kompakt, normal, groß); Kopf- und Fußmaße. + +## 4. Zielsystem + +Leitlinie: Dichte wie bei etwa 75–85 % der heutigen Höhen, Fließtext bei rund 94 % (17 px), freundliche Proportionen bleiben. Nicht verlangt und nicht vorgesehen: `zoom`, `transform: scale()`, globale Prozentskalierung. + +### 4.1 Tokens (Ist → Soll, jeweils Spanne bei Smartphone → Desktop) + +| Token | Ist | Soll | +|---|---|---| +| `--text-small` | 15 px | 14 px | +| `--text-body` | 17 → 18 px | 16 → 17 px (`clamp(1rem, .97rem + .12vw, 1.0625rem)`) | +| `--leading-body` | 1,6 | 1,55 | +| `--text-lede` | 18 → 21 px | 17 → 19 px | +| `--text-h3` | 20 → 22 px | 18 → 20 px | +| `--text-h2` | 26 → 34 px | 22 → 28 px | +| `--text-h1` | 34 → 52 px | 28 → 40 px | +| `--text-display` (neu, nur Seiteneinstieg) | – (Einstieg 32 → 78 px) | 32 → 52 px | +| `--section-space-compact` | 24 → 48 px | 20 → 32 px | +| `--section-space-normal` | 48 → 96 px | 36 → 64 px | +| `--section-space-large` | 72 → 128 px | 52 → 88 px | +| `--section-gap-normal` / `--grid-gap` | 20 → 36 px | 16 → 28 px | +| Kopfzeile Ausgangszustand / kompakt (Desktop) | 104 / 72 px | 80 / 64 px | +| Logo Kopfzeile / Fuß | 60 px (×1,32) / 72 px | 44 px (×1,25) / 52 px (Anzeigegröße, kein neues Asset) | + +Die Schlüssel der Abschnittsstufen (`compact`, `normal`, `large`) und aller Widget-Einstellungen bleiben unverändert; nur ihre Werte ändern sich. + +### 4.2 Komponentenregeln (Soll) + +Gemeinsame Regel: Schriftgrößen aus den Tokens, `cqi` nur als Obergrenze in engen Plätzen (`clamp(1.25rem, 6cqi, var(--text-h2))`). Damit bleibt die Anpassung an den Platz erhalten, ohne zweite Skala. + +| Komponente | Ist | Soll | +|---|---|---| +| Einstieg, Titel | `5,4cqi`, bis 78 px | `clamp(1.9rem, 4cqi, var(--text-display))` | +| Einstieg, Mindesthöhe kompakt / normal / groß | 400 / 512 / 640 px | 288 / 384 / 512 px (nur ab 860 px Containerbreite) | +| Einstieg, Innenabstand | bis 5 rem | `clamp(1.25rem, 3.4cqi, 3.5rem)` | +| Bild und Text, Titel | bis 53,6 px | `clamp(1.4rem, 3.6cqi, var(--text-h2))` | +| Bild und Text, Bild ab 900 px (kompakt / normal / großzügig) | 3:2 / 4:3 / 1:1 | 16:9 / 3:2 / 4:3; Spaltenverhältnis 1,1 : 0,9 | +| Bild und Text, Innenabstand | bis 4,5 rem | `clamp(1.5rem, 3cqi, 3rem)` | +| Premium-Karte, Titel schmal / breit | bis 28 / 32 px | bis `--text-h3` / `--text-h2` (20 / 28 px) | +| Premium-Karte, Innenabstand, Tafel | 20–36 px; 140/220 px | 16–28 px; 112 px | +| Karten, Katalogkarten, Handlungsaufruf | Titel 22–24 / 36 px, Innenabstand 24 / 48 px | Titel `--text-h3` / `--text-h2`, Innenabstand 16–20 / 20–36 px | +| Schaltflächen (alle) | 18 / 15,4 / 14,2 / 15 px | 15 px, Mindesthöhe 44 px | +| Fußbereich | oben bis 5 rem, Grundzeile bis 4,5 rem | oben bis 3,5 rem, Grundzeile bis 3,5 rem | + +### 4.3 Messung des Prototyps (Scratchpad, 1440 px und 390 px) + +Die Regeln aus 4.1 und 4.2 wurden als Überschreibung auf die lokale Kopie gelegt (nicht im Repository). Seitenhöhen sind wegen fehlender Schriften nur Näherungen (siehe Abschnitt 2). + +| Messgröße (`/praevention-im-alltag`) | Ist 1440 | Soll 1440 | Ist 390 | Soll 390 | +|---|---|---|---|---| +| Seitenhöhe | 2128 px | 1759 px (−17 %) | 1747 px | 1582 px (−9 %) | +| Fließtext | 18 px | 17 px | 17,1 px | 16 px | +| Titel Einstieg | 70,8 px | 52 px | 32 px | 30,4 px | +| Titel Bild und Text | 53,6 px | 28 px | 24,3 px | 22,4 px | +| Einstieg (Markenfläche, normal) | 512 px | 384 px | 303 px | 256 px | +| Bild und Text, gesamt | 529 px | 437 px | 459 px | 458 px | +| Bild und Text, Bild | 566 × 424 px | 537 × 358 px | 326 × 204 px | 326 × 204 px | +| Redaktionelle Karten (Liste) | 193 px | 184 px | 211 px | 201 px | +| Katalogkarten | 229 px | 222 px | 228 px | 182 px | +| Kopfzeile / Fußbereich | 104 / 292 px | 80 / 264 px | 64 / 339 px | 64 / 302 px | +| Schaltfläche (Einstieg) | 48 px, 15,4 px | 44 px, 15 px | 48 px | 44 px | + +Startseite `/` bei 1440 px: Seitenhöhe 1662 → 1412 px (−15 %), Einstieg (Foto, kompakt) 400 → 288 px, Titel 72,6 → 52 px, Titel der Premium-Karte 32 → 28 px. + +Smartphone profitiert weniger, weil die Komponenten dort bereits im Sicherheitsumbruch kompakt sind. Der Gewinn liegt auf Desktop und Tablet (768 px: −7 %). + +Hinweis zur Methode: Ein erster Prototypenlauf hatte die Mindesthöhen des Einstiegs ohne Containerbedingung überschrieben und damit den Sicherheitsumbruch unter 860 px ausgehebelt (Einstieg wurde schmal höher statt niedriger). Die Zahlen oben stammen aus dem korrigierten Lauf. Diese Falle ist bei der Umsetzung zu beachten (Abschnitt 6). + +## 5. Abgrenzung und Änderungsumfang + +### 5.1 Wer nutzt welche Regeln? + +| Bereich | Lädt `app.css` / Tokens? | Wirkung einer Tokenänderung | +|---|---|---| +| Öffentliche Website (Seiten, CMS-Widgets, Kopf, Fuß) | ja | beabsichtigt | +| Anmeldung, Mitgliederbereich, Shop, klassische `.sheet`-Seiten | ja (`layouts/member`, `layouts/site`) | **ändert sich mit**: Fließtext, `--text-h3`, Abstände, Schaltflächen, Formulare. `body.member h1/h2` sind fest codiert und folgen nicht | +| CMS-Vorschau in der Verwaltung (Iframes über `WidgetEditor::previewStylesheets()`: Seiteneditor, Kompositionen, Medienvorschau, Gerätevorschau) | ja, nur im Iframe | ändert sich **beabsichtigt** (Vorschau soll die Website zeigen); Abnahmebilder der Verwaltung mit Vorschau werden veraltet | +| Verwaltungsoberfläche (Filament) | nein: kein Filament-Theme, `app.js` importiert kein CSS, `AdminPanelProvider` bindet nur eigene Stile ein; Suche nach Website-Tokens (`--text-*`, `--space-*`, `--section-*` usw.) in `resources/views/filament` und `app/Filament` ohne Treffer | **keine Wirkung** | + +Prüfung der Aussage zur Verwaltung: reine Codesuche, noch keine visuelle Prüfung. Sie gehört in Phase 0 und Phase 3. + +### 5.2 Zu ändernde Dateien + +CSS (Kern): + +- `resources/css/tokens.css`: Typografie, Abschnittsabstände, Kopfzeile, ein neuer Token `--text-display`. +- `resources/css/site.css`: Logogröße, Skalierung, Fußbereich-Innenabstände. +- `resources/css/components.css`: Schaltflächengröße. +- `resources/css/widgets.css`: Titel und Innenabstände von Karten, Katalogkarten, Handlungsaufruf, FAQ. +- `resources/css/components/lf-hero.css`, `lf-bild-text.css`, `lf-premium-card.css`: Titel auf Tokens, Innenabstände, Mindesthöhen, Bildverhältnisse. +- `resources/css/app.css`: nur falls der Mitgliederbereich nachgeführt wird (Entscheidung E5). +- `resources/css/components/lf-shop.css`: voraussichtlich nur Sichtprüfung. + +Nicht-CSS (leicht zu übersehen): + +- `HeroWidget::heights()`: die Bezeichnungen enthalten Pixelwerte („Kompakt (mind. 400 px)“, „Normal (mind. 512 px)“, „Groß (mind. 640 px)“) und müssen mitgeändert werden; die Schlüssel `compact`, `normal`, `large` bleiben. +- Kommentare und Bezeichnungen in `ImageTextWidget`, `SectionStyle` (Verweis auf Tokens) und `hero.blade.php`. +- Dokumentation: `docs/architektur/designsystem.md` §5 (Skala) und §9 (dort steht noch „1,16-fach“ für die Logo-Skalierung, im Code 1,32), `docs/architektur/cms-widget-registry.md` §11 (Pixeltabelle der Abstände), Kopfkommentare der `lf-*.css`. +- Tests: Suche in `tests/` nach den genannten Bezeichnungen und nach Token-/Pixelwerten ohne Treffer (Stichwortsuche, nicht erschöpfend). Nach der Änderung `php artisan test` und Pint wie üblich. + +**Keine Änderung** an Datenmodellen, gespeicherten Inhalten, Lizenz- oder Produktlogik und keine Migration: Abschnittsstufen und Widgethöhen sind Schlüssel, die im CSS auf Werte abgebildet werden. + +### 5.3 Divergenz vom Brand-UI-Kit + +`lf-hero`, `lf-bild-text` und `lf-premium-card` sind Übernahmen aus Kit v1.6/v1.7 mit dokumentierten Anpassungen. Die Änderung vergrößert die Abweichung vom Kit. Ob eine Kit-Ergänzung (z. B. `KIT_ERGAENZUNG_v1.8.md`) nachgeführt wird, ist Entscheidung E6. + +## 6. Risiken + +| Risiko | Einschätzung | Gegenmaßnahme | +|---|---|---| +| Mitgliederbereich, Shop, Anmeldung verändern sich mit | mittel; Fließtext schrumpft 18 → 17 px, feste H1/H2 des Mitgliederbereichs bleiben groß | Sichtprüfung dieser Seiten; Entscheidung E5 | +| Sicherheitsumbruch des Einstiegs unter 860 px wird ausgehebelt, wenn Mindesthöhen außerhalb der Containerbedingung stehen | hoch bei Fehlbedienung (im Prototyp aufgetreten) | Werte in `lf-hero.css` am Platz ändern, wo die Containerregel folgt; Prüfung bei 390, 768, 859, 860 px | +| Lange Titel, schmale Plätze | gering bis mittel | `cqi` als Untergrenze behalten; Prüfung mit langem Titel bei 390 px (Szenario T5 des Zielkonzepts) | +| Vorhandene Seiten mit gespeicherten Abstandsstufen wirken anders | gering, nur Werte ändern sich | Sichtprüfung aller veröffentlichten Seiten | +| Kontrast, Trefferflächen, Zoom | gering | Fließtext nie unter 16 px, Trefferflächen 44 px, Prüfung bei 200 % Zoom und 400 % Reflow, Textabstände nach WCAG 1.4.12 | +| Logo kleiner als im Ist | gering; Logo ist freigegeben, nur die Anzeigegröße ändert sich | Abstimmung E2, kein neues Asset | +| Abnahmebilder der Verwaltung mit Vorschau werden veraltet | gering | Hinweis in Abnahmedateien, bei Bedarf nachziehen | +| Messung weicht von echter Instanz ab | mittel (Abschnitt 2) | Phase 0 an `luf-test` mit echten Schriften | + +## 7. Offene Entscheidungen für die fachliche Abstimmung + +| Nr. | Frage | Empfehlung | +|---|---|---| +| E1 | Fließtext 17 px (Soll) oder 16 px? | 17 px; 16 px nur als Untergrenze auf Smartphone | +| E2 | Anzeigegröße des Logos und Kopfzeile 80 / 64 px | wie 4.1, nach Sichtprüfung | +| E3 | Maximale Titelgröße des Seiteneinstiegs (`--text-display`) 52 px oder 56 px | 52 px | +| E4 | Bild in „Bild und Text“: Höhe weiter begrenzen (Prototyp: 358 px, noch das höchste Element) oder Spalte schmaler (z. B. 0,8 fr)? | Entscheidung nach Sichtprüfung der Referenzseite; Text wird nie begrenzt | +| E5 | Soll der Mitgliederbereich den Tokens folgen (auch feste H1/H2) oder bis zu einer eigenen UX-Abnahme unverändert bleiben? | Tokens folgen lassen, feste Überschriften zunächst belassen; kein zweites Größensystem für `body.member` | +| E6 | Kit-Ergänzung nachführen? | ja, kurz, mit Verweis auf diesen Bericht | +| E7 | Vorgabe neuer Abschnitte: oben und unten „Kompakt“ (Soll 2 × 32 px = 64 px zwischen zwei Abschnitten statt 96 px) | beibehalten | + +## 8. Umsetzungsplan + +Arbeit auf `feature/website-groessenskala`, Merge nach `develop`. Kein Push auf `main`, kein manuelles Deployment. + +**Phase 0 – Ausgangsmessung (kein Code).** An `luf-test` (nicht Prod) mit echten Schriften, Bildern und JavaScript Messung und Bildschirmfotos bei 100 % Zoom (1440, 768, 390) und als 67-%-Referenz. Navigation bei 1440 px prüfen (Menümodus?). Messskript im Repository oder unter `docs/analysen/` ablegen, damit es wiederholbar ist. + +**Phase 1 – Tokens.** Nur `tokens.css` (und der eine neue Token), ohne Komponentenänderung. Messen. Wirkung auf Mitgliederbereich und Shop ansehen. Tests und Pint. + +**Phase 2 – Referenzseite `/praevention-im-alltag`** (enthält Einstieg, Bild und Text, Karten, Katalogkarten; Startseite ergänzend wegen Premium-Karte und Handlungsaufruf). Komponenten in dieser Reihenfolge anpassen: Schaltflächen, Einstieg, Bild und Text, Karten, Katalogkarten, Handlungsaufruf, Kopf und Fuß. Nach jedem Schritt Messung bei 1440, 768, 390 sowie bei den Schwellen 859 / 860 / 899 / 900 px (Container-Abfragen). Prüfung bei 200 % Zoom, 400 % Reflow, Tastatur, Fokus, Kontrast. + +**Phase 3 – Übertragen.** Premium-Karte (alle Varianten, Hoch- und Querformat, ohne Bild, mit Clip), Katalogseiten, FAQ, Überschrift, Prosa, `.sheet`-Seiten. Danach Mitgliederbereich, Shop, Anmeldung (Sichtprüfung, nur bei Befund anpassen). CMS-Vorschau in der Verwaltung ansehen; Verwaltungsoberfläche selbst bleibt unberührt (Gegenprüfung: Vorher-Nachher-Vergleich einer Verwaltungsseite). + +**Phase 4 – Abschluss.** Namen und Pixelangaben in `HeroWidget::heights()` und Kommentaren, Dokumentation (`designsystem.md`, `cms-widget-registry.md`, Kit-Ergänzung), Bildschirmfotos unter `docs/analysen/…-screenshots/`, `php artisan test` und Pint, Merge nach `develop`. Visuelle Freigabe bei 100 % Zoom durch Lars, bevor `develop` → `main` (manueller Schritt von Lars) vorbereitet wird. + +Größenordnung: Phase 1–2 klein (acht bis zehn CSS-Dateien, ein PHP-Label), Phase 3 überwiegend Prüfung. diff --git a/docs/architektur/12_Entscheidungsprotokoll_ADR.md b/docs/architektur/12_Entscheidungsprotokoll_ADR.md index 485b01b..fe2a28d 100644 --- a/docs/architektur/12_Entscheidungsprotokoll_ADR.md +++ b/docs/architektur/12_Entscheidungsprotokoll_ADR.md @@ -64,6 +64,7 @@ ## Übersicht der Architekturentscheidungen | ADR-41 | Gemeinsame Redaktionsbasis | Auf Test (19.11.2026, `develop` `f29ea58`); Betreiberabnahme offen. Technische Abbildung ist eine Arbeitsannahme, keine neue fachliche Freigabe | Klasse-A-Texte, Fachdimensionen und Präsentationsreferenzen an den bestehenden Fachobjekten; keine zweite Inhalts- oder Produktverwaltung | | ADR-42 | Angebot und Warenkorb | Fachlich beschlossen | Gemeinsame Angebotsseite mit Lizenzwahl, Mehrangebotswarenkorb und Geltung der Bestellfassung je Position | | ADR-43 | Trailer auf Karten | Umgesetzt auf Test (21.11.2026); Abnahme offen | Medien-, Programm- und Modulkarte spielen den für die Website freigegebenen Trailer beim Überfahren oder Antippen; ohne Freigabe nur das Bild | +| ADR-44 | Gemeinsame, konfigurierbare Größenskala | Umgesetzt auf `develop` (22.11.2026); Abnahme durch den Betreiber offen | Zehn Basiswerte steuern Typografie, Abstände, Kopfzeile, Breite und Bildhöhen für Website, CMS-Vorschau und gemeinsam genutzte Komponenten; einstellbar in „Website → Design → Größen“ ohne Deployment | --- @@ -580,3 +581,19 @@ ## ADR-43 – Trailer auf Karten **Nachtrag Hero (22.11.2026).** Das Hero-Widget (Variante „Foto mit Textfläche“) kann ein Video zeigen: optionale Auswahl `refs.video` (ein Film aus dem Medienmanager, Klasse `HeroVideo`, Skript `resources/js/hero-video.js`). Der Clip folgt derselben Regel wie auf der Karte (Trailer, sonst Vorschauclip, sonst die freigegebene Website-Datei des Films; nie der vollständige Film, nie ein nicht freigegebener Clip). Er läuft stumm auf der Fläche des Fotos und startet nach dem Laden der Seite von selbst, sobald der Einstieg im Bild ist; das Foto bleibt darunter, bis das erste Videobild da ist, und ist der Rückfall bei Fehlern. Eine Schaltfläche „Video“ hält an und spielt ab (WCAG 2.2.2). Bei „reduzierte Bewegung“, im Datensparmodus und bei 2G startet nichts von selbst, nur auf Bedienung und ohne Schleife. Er hält an, wenn der Einstieg aus dem Bild scrollt, und läuft nur weiter, wenn er von selbst lief und nicht angehalten wurde. In der Markenfläche (`editorial_solid`) gibt es kein Video. Neuer Schlüssel ohne Versionssprung, keine Migration. Hinweis „Mit Ton starten“ und Video als Seitenhintergrund bleiben ausgeschlossen. **Quelle.** `docs/ux/verwaltung/04-fachliche-anforderungen.md` FACH-46; `medienzugriff-fuer-komponenten.md`; `cms-widget-registry.md`; ADR-39, ADR-40, ADR-41. +## ADR-44 – Gemeinsame, konfigurierbare Größenskala + +**Status am 22.11.2026:** Umgesetzt auf `develop` (Branch `feature/design-groessen`); Abnahme durch den Betreiber offen. Konkretisiert ADR-36 (gemeinsames Designsystem) für Maße und ersetzt dort die Aussage „frei pflegbare Werte im CMS“ als verworfene Alternative durch eine bewusst kleine, begrenzte Konfiguration. +**Kontext.** Die Analyse vom 22.11.2026 (`docs/analysen/website-groessenskala-analyse-2026-11-22.md`) fand drei parallele Größensysteme: die Tokens in `tokens.css`, die aus dem Brand-UI-Kit übernommenen Komponenten (`lf-hero`, `lf-bild-text`, `lf-premium-card`) mit eigenen `cqi`-, `rem`- und `px`-Werten sowie feste Mindesthöhen und containerprozentuale Innenabstände. Folge: Titel in Komponenten größer als die Seiten-H1, vier Schaltflächengrößen, Einstieg und Bild und Text bestimmten ihre Höhe über Mindesthöhe und Bildformat. „Kompakt“ setzte überall auf einem großen Maßstab auf. Website und Mitgliederbereich sollen langfristig ein einheitliches Erscheinungsbild haben, bei unterschiedlichen Layouts und Dichten. +**Entscheidung.** +- **Zehn Basiswerte** (Pixel als ganze Zahl, mit Wertebereich): Fließtext 17, Überschrift 1 40, Überschrift 2 28, Display-Überschrift (Höchstwert) 52, Basisabstand 8, Abschnittsabstand (Desktop) 48, Karten-Innenabstand 20, Höhe der Kopfzeile 80, maximale Inhaltsbreite 1312, Bildhöhe in Bild und Text (Desktop) 320. Alles Weitere wird abgeleitet und ist nicht einzeln einstellbar. +- **Eine Quelle für die Ableitung:** `resources/css/tokens.css` (Block „Größenskala“) enthält die Standardwerte (`--ds-*`) und alle Ableitungsregeln (`calc`/`clamp`, in rem, damit die Textgröße des Browsers wirkt). Die Komponenten verwenden ausschließlich die abgeleiteten Tokens (`--text-*`, `--space-*`, `--pad-card`, `--pad-surface`, `--section-*`, `--media-h`, `--dens`); `cqi` dient nur noch als Obergrenze in engen Plätzen. Es gibt kein zweites Größensystem. Die Standardwerte stehen zusätzlich in `App\Domain\Design\DesignScale`; ein Test hält beide gleich. +- **Dichtestufen:** Die gespeicherten Schlüssel der Größenvarianten bleiben (`compact`, `normal`, `large`, `spacious`). `--dens` bildet sie einheitlich ab: kompakt 0,75, standard 1, großzügig 1,3. Bei Einstieg und Bild und Text bestimmt sie Bildhöhe, Mindesthöhe, Abstand und Innenabstand. Nur die Bezeichnungen ändern sich (Kompakt, Standard, Großzügig), ohne Pixelangaben; keine Datenänderung, keine Migration der Inhalte. +- **Konfiguration in der Verwaltung:** Seite „Website → Design → Größen“ (`App\Filament\Pages\DesignGroessen`, Navigationsgruppe „Design“), nur für den Systemverwalter. Arbeitsstand mit einer Speicherhandlung, Prüfung der Wertebereiche und der Reihenfolge (Fließtext + 6 ≤ Überschrift 2, Überschrift 2 + 4 ≤ Überschrift 1 ≤ Display), „Standardwerte wiederherstellen“ mit Bestätigung. Speicher: Tabelle `site_settings` (Schlüssel `design.scale`, JSON), rein ergänzende Migration; ohne Zeile gelten die Standardwerte, „Wiederherstellen“ löscht die Zeile. +- **Wirkung ohne Deployment:** Abweichende Werte werden als Inline-Stylesheet (``) nach dem Stylesheet in `layouts/site`, `layouts/member` und in alle CMS-Vorschauen (`WidgetEditor::previewStylesheets()`) eingefügt. Ausgegeben werden nur geprüfte ganze Zahlen zu bekannten Schlüsseln. Lesen ist ausfallsicher: fehlende Tabelle, Datenbankfehler oder beschädigte Daten ergeben die Standardwerte, nie eine Fehlerseite (deshalb ist auch ein Code-Rollback folgenlos). +- **Nicht einstellbar (Barrierefreiheit):** Trefferflächen 44 px; Fließtext nie unter 16 px, auch auf Smartphones; Fokusdarstellung. +- **Mitgliederbereich:** Er verwendet dieselben Tokens und folgt daher Fließtext, Überschrift 3, kleiner Schrift und Abstandsraster. Seine festen Überschriften H1/H2 und sein Layout bleiben unverändert. Kopfzeile, Abschnittsabstände, Inhaltsbreite und Bildhöhen werden nur von der öffentlichen Website verwendet. Die Überarbeitung des Mitgliederbereichs nach seinem eigenen Design-Kit ist ein eigenes Arbeitspaket und nutzt diese Grundlage. +- **Verwaltungsoberfläche:** Die Filament-Oberfläche lädt `app.css` nicht und bleibt unberührt. Die Vorschau-Iframes laden es und zeigen deshalb die aktiven Werte. +**Alternativen.** Je CSS-Eigenschaft eine Einstellung (verworfen: nicht wartbar, Fehleinstellungen); Größen nur im Code (verworfen: Betreiber will praktisch feinjustieren); Ableitung in PHP und Ausgabe aller Tokens (verworfen: zweite Quelle der Regeln neben dem Stylesheet); `zoom`, `transform: scale()` oder globale Prozentskalierung (verworfen: Lesbarkeit, Barrierefreiheit); getrennte Skalen für Website und Mitgliederbereich (verworfen: widerspricht ADR-36). +**Folgen.** Neue Komponenten verwenden die abgeleiteten Tokens, keine eigenen Größen. Neue Basiswerte erfordern Eintrag in `tokens.css` und `DesignScale::PARAMETERS`. Die Kit-Komponenten weichen weiter vom Brand-UI-Kit v1.6/v1.7 ab (dokumentiert in `designsystem.md` §15). Die Abnahmebilder der Verwaltung mit Vorschau sind bei Änderung der Werte nicht mehr maßgeblich für Größen. +**Quelle.** Analysebericht vom 22.11.2026; Designprinzipien §§5, 9, 11–13; ADR-36, ADR-38, ADR-39; `designsystem.md` §15. diff --git a/docs/architektur/cms-widget-registry.md b/docs/architektur/cms-widget-registry.md index 97879cb..b484a20 100644 --- a/docs/architektur/cms-widget-registry.md +++ b/docs/architektur/cms-widget-registry.md @@ -70,10 +70,10 @@ ## 4. Registrierte Widget-Arten | Kennung | Name | Version | Varianten | Breiten (Einheiten) | Höhen | Verweise | |---|---|---|---|---|---|---| -| `hero` | Einstieg (Hero), Premium nach Kit v1.6 | 2 | `photo_split` (Foto mit Textfläche), `editorial_solid` (Navy-Markenfläche) | 3, 4 | `compact` (mind. 400 px), `normal` (512 px, Vorgabe), `large` (640 px) | `refs.image`, `refs.video` (optional) | +| `hero` | Einstieg (Hero), Premium nach Kit v1.6 | 2 | `photo_split` (Foto mit Textfläche), `editorial_solid` (Navy-Markenfläche) | 3, 4 | `compact` (Kompakt), `normal` (Standard, Vorgabe), `large` (Großzügig); Mindesthöhe aus der Größenskala (ADR-44) | `refs.image`, `refs.video` (optional) | | `heading` | Überschrift und Einleitung | 1 | `standard` | 1–4 | – | – | | `prose` | Fließtext | 1 | `standard` | 1–4 | – | – | -| `image_text` | Bild und Text, Premium nach Kit v1.6 | 3 | `image_left`, `image_right` (Bildseite) | 1–4 | `compact`, `normal` (Vorgabe), `spacious` | `refs.image` | +| `image_text` | Bild und Text, Premium nach Kit v1.6 | 3 | `image_left`, `image_right` (Bildseite) | 1–4 | `compact` (Kompakt), `normal` (Standard, Vorgabe), `spacious` (Großzügig) | `refs.image` | | `cards` | Redaktionelle Karten | 1 | `standard` (Raster), `compact` (Liste), `featured` (erste Karte hervorgehoben) | 1–4 | – | Bild je Karte in `data.items[].image` | | `catalog_cards` | Programm- und Modulkarten | 1 | `standard`, `compact` | 1–4 | – | `refs.items[] = {type: composition, id}` | | `topic_card` | Themenkarte, Premium-Karte nach Kit v1.7 | 1 | `adaptive`, `stacked` | 1–4 | `auto` (Vorgabe), `fill` | `refs.pillar`, `refs.image` | @@ -243,14 +243,16 @@ ## 11. Abschnitte und Plätze - **Leere Plätze** gibt es im Editor. Öffentlich entfallen sie; die übrigen Plätze teilen sich die Breite im Verhältnis ihrer Einheiten. Ein Abschnitt ohne darstellbares Widget entfällt samt Fläche und Trenner. - **Gestaltung**: nur Aufzählungswerte (`SectionStyle`), abgebildet auf Tokens. Freie Werte (Farbcodes, CSS, unbekannte Schlüssel) werden abgewiesen. - Hintergrund: Standard, helle Markenfläche, dunkle Markenfläche, Markenakzent, Hintergrundbild. Jede Fläche setzt die Bedeutungs-Tokens neu (`scope-dark`, `scope-accent`, `scope-light`). - - Breite: schmal (45 rem), Standard (75 rem), breit (90 rem), volle Breite. Der Hintergrund reicht immer über die ganze Bildschirmbreite. + - Breite: schmal (44 rem), Standard (Inhaltsbreite, Basiswert 1312 px), breit (1,17-fach), volle Breite. Der Hintergrund reicht immer über die ganze Bildschirmbreite. - **Abstände (Version 2): genau drei unabhängige Werte**, je Kein Abstand / Kompakt / Normal / Großzügig: | Wert | Bedeutung | Stufen (390 px → 1440 px) | |---|---|---| - | `spacing_top` | Abstand oben (vor dem Inhalt) | 0 / 24 → 45 / 48 → 90 / 72 → 120 px (`--section-space-*`) | + | `spacing_top` | Abstand oben (vor dem Inhalt) | 0 / 24 → 32 / 36 → 48 / 48 → 72 px (`--section-space-*`; Smartphone → Desktop, bei Standardwerten) | | `spacing_bottom` | Abstand unten (nach dem Inhalt) | wie oben | - | `gap` | Widget-Abstand zwischen den Plätzen des Rasters, nebeneinander und gestapelt | 0 / 12 → 18 / 20 → 36 / 32 → 56 px (`--section-gap-*`) | + | `gap` | Widget-Abstand zwischen den Plätzen des Rasters, nebeneinander und gestapelt | 0 / 12 → 16 / 16 → 28 / 24 → 40 px (`--section-gap-*`) | + + Die Pixelwerte sind seit ADR-44 aus den Basiswerten „Abschnittsabstand“ (Normal; Kompakt ⅔, Großzügig 1,5-fach) und „Basisabstand“ abgeleitet und in „Website → Design → Größen“ einstellbar; die Schlüssel (`compact`, `normal`, `large`) und gespeicherte Seiten bleiben unverändert. - Zwischen zwei Abschnitten addieren sich „unten“ des ersten und „oben“ des zweiten; 0 + 0 = 0. Es gibt keine weitere Vorgabe aus Seiten- oder Rasterhüllen (geprüft: kein Außenabstand der Abschnitte, `main` ohne Innenabstand). - Oben und unten sind der Innenabstand des Abschnitts. Bei eigener Fläche (dunkel, Akzent, Bild) liegen sie innerhalb der Fläche, damit Hintergründe nahtlos anschließen. @@ -280,8 +282,8 @@ ## 12. Responsive Widget-Regeln und gemeinsamer Layoutvertrag (ADR-38) | Widget | Breiten | Höhen | Darstellung nach Containerbreite | |---|---|---|---| -| Einstieg (Hero) | 3, 4 | compact/normal/large | ab 860 px Foto über die Fläche, Text links, Mindesthöhe 400/512/640 px; darunter Sicherheitsumbruch: Foto 16:9 über dem Text, Höhe nach Inhalt; unter 440 px Schaltflächen untereinander | -| Bild und Text | 1–4 | compact/normal/spacious | unter 540 px gestapelt, Schaltflächen in voller Breite; 540–899 px flacher Bildstreifen (2,5 : 1 / 2,15 : 1 / 1,8 : 1) über dem Text; ab 900 px zweispaltig, Bild links oder rechts | +| Einstieg (Hero) | 3, 4 | compact/normal/large | ab 860 px Foto über die Fläche, Text links, Mindesthöhe 288/384/499 px bei Standardwerten (0,9-/1,2-/1,56-Faches der Bildhöhe aus der Größenskala); darunter Sicherheitsumbruch: Foto 16:9 über dem Text, Höhe nach Inhalt; unter 440 px Schaltflächen untereinander | +| Bild und Text | 1–4 | compact/normal/spacious | unter 540 px gestapelt, Schaltflächen in voller Breite; 540–899 px flacher Bildstreifen (2,5 : 1 / 2,15 : 1 / 1,8 : 1) über dem Text, nie höher als die Zielhöhe; ab 900 px zweispaltig (1,1 : 0,9), Bild links oder rechts, Bildhöhe = Zielhöhe 240/320/416 px bei Standardwerten | | Überschrift | 1–4 | – | Größe folgt der Platzbreite, lange Wörter werden getrennt | | Fließtext | 1–4 | – | Zeilenlänge höchstens etwa 70 Zeichen, lange Adressen brechen um | | Redaktionelle Karten | 1–4 | – | so viele Karten nebeneinander, wie bei 15 rem Kartenbreite passen; hervorgehobene Karte ab 44 rem mit Bild neben dem Text | diff --git a/docs/architektur/designsystem.md b/docs/architektur/designsystem.md index d5b238f..312d971 100644 --- a/docs/architektur/designsystem.md +++ b/docs/architektur/designsystem.md @@ -1,6 +1,6 @@ # Gemeinsames Designsystem (ADR-36) – umgesetzter Stand -Stand: 18.11.2026, Designiteration 1 (Branch `feature/design-iteration-1`; Vorstand 17.11.2026 `feature/cms-sections`). Gilt für öffentliche Website, Anmeldung, Mitgliederbereich und Mitgliederbibliothek; später für Warenkorb und Checkout. Die Verwaltung nutzt dieselben Markenfarben und Schriftrollen. Ihre Maße und der Arbeitsplatzrahmen stehen in [Verwaltungstokens](../ux/verwaltung/tokens.md) und folgen dem [Verwaltungsstandard](../ux/verwaltung/14-verwaltungsstandard.md). Öffentliche Website und fachliche Verträge bleiben davon unberührt. +Stand: 22.11.2026 (Größenskala, ADR-44, Abschnitt 15); davor 18.11.2026, Designiteration 1 (Branch `feature/design-iteration-1`; Vorstand 17.11.2026 `feature/cms-sections`). Gilt für öffentliche Website, Anmeldung, Mitgliederbereich und Mitgliederbibliothek; später für Warenkorb und Checkout. Die Verwaltung nutzt dieselben Markenfarben und Schriftrollen. Ihre Maße und der Arbeitsplatzrahmen stehen in [Verwaltungstokens](../ux/verwaltung/tokens.md) und folgen dem [Verwaltungsstandard](../ux/verwaltung/14-verwaltungsstandard.md). Öffentliche Website und fachliche Verträge bleiben davon unberührt. **Status der Werte:** Alle Markenwerte, Schriften und die Wortmarke sind **vorläufig**. Sie stammen aus `docs/Brand-UI-Kit/02_design_tokens` (Entwurf vom 15.11.2026, aus den Originalmotiven abgeleitet, laut Kit nicht freigegeben) und aus der Empfehlung im Website-Zielkonzept §7.2. Diese Datei ist keine Markenfreigabe. Eine Freigabe ändert ausschließlich `resources/css/tokens.css` (und für die Wortmarke `resources/views/components/site/brand.blade.php`, für die Markenakzente `resources/views/components/brand/`). @@ -8,7 +8,9 @@ ## 1. Dateien | Datei | Inhalt | |---|---| -| `resources/css/tokens.css` | Ebene 1 Markenwerte (`--lf-*`), Ebene 2 Bedeutungswerte (`--color-*`), Typografie, Abstände, Rundungen, Layoutmaße, Flächen-Gültigkeitsbereiche `.scope-dark`, `.scope-accent`, `.scope-light` | +| `resources/css/tokens.css` | Ebene 1 Markenwerte (`--lf-*`), Ebene 2 Bedeutungswerte (`--color-*`), **Größenskala** (zehn Basiswerte `--ds-*` und alle abgeleiteten Größen, Abschnitt 15), Rundungen, Layoutmaße, Flächen-Gültigkeitsbereiche `.scope-dark`, `.scope-accent`, `.scope-light` | +| `app/Domain/Design/` | `DesignScale` (Basiswerte, Wertebereiche, Prüfung), `DesignSettings` (Lesen, Speichern, Zurücksetzen, Inline-Stylesheet), `SiteSetting` (Tabelle `site_settings`) | +| `app/Filament/Pages/DesignGroessen.php` | Verwaltungsseite „Website → Design → Größen“ | | `resources/css/base.css` | Grundelemente, Überschriften, Links, Fokus, Sprunglink, `prefers-reduced-motion` | | `resources/css/components.css` | Grundkomponenten: Container, Schaltflächen, Formulare, Statusanzeigen, Karte, Dialog, Kennzeile, Themensignatur, Redaktionshinweise | | `resources/css/site.css` | Website-Gerüst: Wortmarke, Kopfzeile (zwei Zustände), Hauptnavigation, Menümodus, Inhaltsfläche, Fußbereich, Markenakzente | @@ -72,11 +74,11 @@ ## 5. Typografie, Abstände, Maße |---|---| | Auszeichnung (H1–H3, Wortmarke) | Nunito 700/800, vorläufig | | Lesen und Bedienen | Source Sans 3 400/600 (bereits bisher verwendet) | -| Skala | Fließtext 17 → 18 px, Zeilenhöhe 1,6; H3 20 → 22; H2 26 → 34; H1 34 → 52; Lesebreite 70 Zeichen | -| Abstände | Grundmaß 4 px: 4, 8, 12, 16, 24, 32, 48, 64, 96 px | +| Skala | Seit ADR-44 aus Basiswerten abgeleitet (Abschnitt 15). Standard bei Desktop: Fließtext 17 px (Smartphone 16), Zeilenhöhe 1,55; H3 20; H2 28; H1 40; Display bis 52; kleine Schrift 14; Schaltflächen 15; Lesebreite 70 Zeichen | +| Abstände | Basisabstand 8 px (einstellbar): halber bis zwölffacher Wert = 4, 8, 12, 16, 24, 32, 48, 64, 96 px | | Rundungen | 8 (klein), 14 (Karte), 22 (Fläche), Pille | -| Breiten | Lesebereich 44 rem, Standard 82 rem, Breit 96 rem, Vollbreite; Randabstand 16–40 px (siehe Abschnitt 12) | -| Abschnittsabstände | `--section-space-{none,compact,normal,large}` (oben/unten) und `--section-gap-{none,compact,normal,large}` (Widget-Abstand); Bedeutung in `cms-widget-registry.md` §11 | +| Breiten | Lesebereich 44 rem, Standard 1312 px (einstellbar), Breit 117 % davon, Vollbreite; Randabstand 16–40 px (siehe Abschnitt 12) | +| Abschnittsabstände | `--section-space-{none,compact,normal,large}` (oben/unten) und `--section-gap-{none,compact,normal,large}` (Widget-Abstand), abgeleitet aus Abschnittsabstand und Basisabstand (Abschnitt 15); Bedeutung in `cms-widget-registry.md` §11 | | Trefferfläche | mindestens 44 × 44 px | | Fokus | 3 px Rahmen in `--color-focus`, 3 px Abstand, auf jeder Fläche sichtbar | @@ -120,7 +122,7 @@ ## 8. Themensignaturen (vorbereitet) ## 9. Website-Gerüst (Designiteration 1) - **Wortmarke**: freigegebene Lara-&-Felix-Wortmarke (Kompaktfassung) als Bild mit festen Maßen im Markup; die Breitenmessung der Navigation stimmt dadurch schon vor dem Laden des Bildes. -- **Kopfzeile, zwei Zustände ohne Layoutsprung.** Die Box ist immer `--header-height-initial` hoch (104 px ab 75 rem, sonst 64 px) und klebt mit negativem Abstand (`top: kompakt − initial`). Die innere Leiste (`.site-header-bar`, 72 px) klebt oben. Beim Scrollen wandert sie 16 px nach oben und bleibt dann stehen; der Seitenfluss ändert sich nie. Ein Beobachter (`data-site-header-sentinel`) setzt `.is-compact`: Wortmarke von 1,16-facher auf normale Größe (nur `transform`) und Schatten. Unter `prefers-reduced-motion` ohne Übergang. Ohne JavaScript klebt die Kopfzeile genauso; nur die Wortmarke bleibt groß. +- **Kopfzeile, zwei Zustände ohne Layoutsprung.** (Maße seit ADR-44 aus dem Basiswert „Höhe der Kopfzeile“, Standard 80: Box 80 px ab 75 rem, sonst 64 px, kompakte Leiste 64 px, Wortmarke im Ausgangszustand 1,25-fach; die folgenden Pixelangaben nennen den Stand vor ADR-44.) Die Box ist immer `--header-height-initial` hoch (104 px ab 75 rem, sonst 64 px) und klebt mit negativem Abstand (`top: kompakt − initial`). Die innere Leiste (`.site-header-bar`, 72 px) klebt oben. Beim Scrollen wandert sie 16 px nach oben und bleibt dann stehen; der Seitenfluss ändert sich nie. Ein Beobachter (`data-site-header-sentinel`) setzt `.is-compact`: Wortmarke von 1,16-facher auf normale Größe (nur `transform`) und Schatten. Unter `prefers-reduced-motion` ohne Übergang. Ohne JavaScript klebt die Kopfzeile genauso; nur die Wortmarke bleibt groß. - **Breitenstufen der Navigation** (`site-nav.js`, Messung an einer unsichtbaren Kopie): 1. Navigation und Kontozugang mit Beschriftung in einer Zeile; 2. sonst Kontozugang nur als Symbol (`.is-account-compact`); 3. sonst und immer unter 75 rem Menümodus (`.is-menu-mode`). Die Navigation bricht nie um; deshalb ist die Kopfzeile auf allen Seiten gleich hoch, unabhängig von Anzahl und Länge der CMS-Einträge. Die Messung steht inline direkt nach der Kopfzeile (`window.lufHeaderMode`) und setzt die Stufe vor dem ersten Zeichnen; `site-nav.js` wiederholt sie bei Größenänderungen und nach dem Laden der Schriften. - **Hauptnavigation**: aus `navigation_items` (`header`), aktiver Eintrag mit gelber Markenunterstreichung und `aria-current`, eine Ebene Untermenü als Aufklappliste (Schaltfläche mit `aria-expanded`, Escape schließt, Klick außerhalb schließt). - **Menümodus**: Menü-Schaltfläche (Symbol und Text) öffnet eine Fläche direkt unter dem sichtbaren Teil der Kopfzeile, 48 px hohe Einträge, Untermenüs eingerückt; Fokus springt in das Menü, Tabulator läuft im Kreis zwischen Schaltfläche und Einträgen, Escape schließt und gibt den Fokus zurück. Keine untere Navigationsleiste auf der Website. Ohne JavaScript bleibt die Navigation unter 75 rem als umbrechende Liste sichtbar. @@ -172,3 +174,54 @@ ## 14. Premium-Karten (Brand-UI-Kit v1.7, Entwurf, ADR-39) - Schriften: Titel `--font-display` 800, Text `--font-reading`; keine neuen Schriften. - Ab 520 px Platzbreite Bild 42 % neben Text 58 %; Bildformat 16:9, 1:1 oder 3:4 bleibt erhalten; kein line-clamp. - Status: Entwurf zur visuellen Freigabe; auf der Testinstanz nur mit gekennzeichneten Platzhalterbildern. + +## 15. Größenskala (ADR-44, 22.11.2026) + +**Ziel.** Eine einzige, zentral steuerbare Größenskala für Website, CMS-Vorschau und gemeinsam genutzte Komponenten; kompakte Darstellung bei 100 % Browserzoom, ohne `zoom`, `transform: scale()` oder globale Prozentskalierung. + +### 15.1 Basiswerte (einstellbar) + +Pixel als ganze Zahl. Standard und zulässiger Bereich stehen in `App\Domain\Design\DesignScale::PARAMETERS` und (Standard) in `tokens.css` (`--ds-*`). + +| Basiswert | Variable | Standard | Bereich | Wirkung | +|---|---|---:|---:|---| +| Fließtext | `--ds-body` | 17 | 16–20 | Desktop; Smartphone 1 px weniger, nie unter 16; leitet kleine Schrift, Einleitung, Überschrift 3, Schaltflächentext ab | +| Überschrift 1 | `--ds-h1` | 40 | 30–56 | Seitentitel Desktop; Smartphone ≈ 70 % | +| Überschrift 2 | `--ds-h2` | 28 | 22–40 | Abschnittstitel; auch Titel in Bild und Text, Handlungsaufruf, breite Karten | +| Display-Überschrift (Höchstwert) | `--ds-display` | 52 | 36–80 | Titel des Einstiegs, wächst mit der Platzbreite bis zu diesem Wert | +| Basisabstand | `--ds-space` | 8 | 6–12 | `--space-1…9` (0,5- bis 12-fach) und `--section-gap-*` | +| Abschnittsabstand (Desktop) | `--ds-section` | 48 | 24–96 | Stufe Normal; Kompakt ⅔, Großzügig 1,5-fach; Smartphone kleiner | +| Karten-Innenabstand | `--ds-card-pad` | 20 | 12–32 | `--pad-card` (Smartphone 80 %), `--pad-surface` (2,4-fach) für große Flächen | +| Höhe der Kopfzeile | `--ds-header` | 80 | 56–112 | Ausgangszustand Desktop; beim Scrollen und mobil 80 %; Anzeigegröße der Wortmarke folgt | +| Maximale Inhaltsbreite | `--ds-width` | 1312 | 960–1600 | Standardraster; Breit = 1,17-fach; Lesebereich bleibt 44 rem | +| Bildhöhe Bild und Text (Desktop) | `--ds-media` | 320 | 200–480 | Bildhöhe Variante Standard; Mindesthöhe des Einstiegs = 1,2-fach | + +Prüfregeln (Verwaltung und Lesen): Fließtext + 6 ≤ Überschrift 2; Überschrift 2 + 4 ≤ Überschrift 1 ≤ Display. Nicht einstellbar: Trefferflächen (44 px), Untergrenze 16 px für Fließtext, Fokusdarstellung. + +### 15.2 Ableitung und Verwendung + +- **Alle Regeln stehen in `tokens.css`.** Fließende Werte zwischen 360 und 1200 px Fensterbreite (`--fl`), Minimum auf kleinen Bildschirmen, Maximum ab 75 rem; Umrechnung in rem, damit die Browser-Textgröße wirkt. Überschriften bleiben auf jeder Breite größer als der Text. +- **Abgeleitete Tokens:** `--text-small|body|lede|h3|h2|h1|display|button`, `--space-1…9`, `--pad-card`, `--pad-surface`, `--section-space-{compact,normal,large}`, `--section-gap-{compact,normal,large}`, `--grid-gap`, `--width-standard|wide`, `--header-height(-initial)`, `--media-h`. +- **Komponenten** (Einstieg, Bild und Text, Premium-Karten, redaktionelle und Katalogkarten, Handlungsaufruf, FAQ, Kopf, Fuß, Schaltflächen) verwenden nur diese Tokens. `cqi` bleibt als Zwischenwert in engen Plätzen, nach oben begrenzt durch das Token (z. B. `clamp(1.4rem, 3.6cqi, var(--text-h2))`). Neue Komponenten definieren keine eigenen Größen. +- **Dichtestufen** der Größenvarianten über `--dens` (kompakt 0,75, standard 1, großzügig 1,3): Einstieg (`compact`, `normal`, `large`) und Bild und Text (`compact`, `normal`, `spacious`) skalieren Bildhöhe, Mindesthöhe, Abstand und Innenabstand einheitlich. Die Mindesthöhen des Einstiegs gelten wie bisher nur ab 860 px Containerbreite; die Regel des Sicherheitsumbruchs steht in `lf-hero.css` nach den Höhenregeln und muss dort bleiben. +- **Bild und Text:** Ab 900 px Containerbreite füllt das Bild seine Spalte und hat die Zielhöhe `--ds-media × --dens` (Standard 320 px, kompakt 240, großzügig 416), unabhängig vom Seitenverhältnis der Datei; es wächst nur, wenn der Text höher ist. Spalten 1,1 : 0,9. Im Streifen (540–899 px) und gestapelt (< 540 px) ist die Bildhöhe auf dieselbe Zielhöhe begrenzt. Der Bildausschnitt folgt weiter dem Fokuspunkt (`--bt-focus-x/y`). + +### 15.3 Konfiguration in der Verwaltung + +- **Fundstelle:** „Website → Design → Größen“ (`/verwaltung/design/groessen`, Navigationsgruppe „Design“, Kopfzeile „Website / Design / Größen“). Zugriff nur für den Systemverwalter. +- **Ablauf:** Arbeitsstand mit Statuszeile („Änderungen nicht gespeichert“ / „Eigene Werte gespeichert“ / „Standardwerte aktiv“); „Größen speichern“ prüft Wertebereiche und Reihenfolge, schreibt in `site_settings` (Schlüssel `design.scale`) und wirkt **sofort**, ohne Deployment, auf die Website und alle CMS-Vorschauen. „Standardwerte wiederherstellen …“ (mit Bestätigung) löscht die Zeile. „Website ansehen“ zeigt den gespeicherten Stand. Strg+S speichert. +- **Auslieferung:** Abweichende Werte kommen als `', (string) DesignSettings::styleTag()); + } + + public function test_invalid_input_is_not_stored(): void + { + $errors = DesignSettings::save([...DesignScale::defaults(), 'body' => 40]); + + $this->assertArrayHasKey('body', $errors); + $this->assertSame(0, SiteSetting::query()->count()); + $this->assertSame(DesignScale::defaults(), DesignSettings::values()); + } + + public function test_reset_removes_the_row_and_restores_the_defaults(): void + { + DesignSettings::save([...DesignScale::defaults(), 'h1' => 44]); + $this->assertSame(44, DesignSettings::values()['h1']); + + DesignSettings::reset(); + + $this->assertSame(DesignScale::defaults(), DesignSettings::values()); + $this->assertSame(0, SiteSetting::query()->count()); + $this->assertSame('', (string) DesignSettings::styleTag()); + } + + public function test_damaged_stored_data_falls_back_to_the_defaults(): void + { + SiteSetting::query()->create(['key' => DesignSettings::KEY, 'value' => ['body' => 999, 'h1' => 'x']]); + DesignSettings::flush(); + + $this->assertSame(DesignScale::defaults(), DesignSettings::values()); + $this->assertSame('', (string) DesignSettings::styleTag()); + } + + public function test_a_missing_table_does_not_break_the_public_site(): void + { + $this->publishPage(); + Schema::drop('site_settings'); + DesignSettings::flush(); + + $this->get('/groessen')->assertOk()->assertSee('Größen')->assertDontSee('lf-design-scale', false); + $this->assertSame(DesignScale::defaults(), DesignSettings::values()); + } + + // --------------------------------------------------------------------------------------------------------------- + // Wirkung auf Website, Anmeldung, Mitgliederbereich und Vorschau + // --------------------------------------------------------------------------------------------------------------- + + public function test_the_public_site_the_login_and_the_member_area_use_the_stored_values_after_the_stylesheet(): void + { + $this->publishPage(); + DesignSettings::save([...DesignScale::defaults(), 'body' => 19, 'header' => 96]); + + foreach (['/groessen', '/anmelden'] as $path) { + $html = $this->get($path)->assertOk()->getContent(); + $this->assertStringContainsString('', $html, $path); + } + + $member = User::factory()->create(); + $html = $this->actingAs($member)->get(route('member.dashboard'))->getContent(); + $this->assertStringContainsString('--ds-body:19;', $html, 'Der Mitgliederbereich nutzt dieselbe Skala.'); + } + + public function test_defaults_add_no_inline_block_to_the_page(): void + { + $this->publishPage(); + + $this->get('/groessen')->assertOk()->assertDontSee('lf-design-scale', false); + } + + public function test_the_cms_previews_use_the_same_active_values(): void + { + $this->assertStringNotContainsString('lf-design-scale', WidgetEditor::previewStylesheets()); + + DesignSettings::save([...DesignScale::defaults(), 'h2' => 30, 'media' => 360]); + + $this->assertStringContainsString(':root{--ds-h2:30;--ds-media:360;}', WidgetEditor::previewStylesheets()); + } + + // --------------------------------------------------------------------------------------------------------------- + // Verwaltungsseite + // --------------------------------------------------------------------------------------------------------------- + + public function test_only_the_system_administrator_may_open_the_page(): void + { + $editor = User::factory()->redakteur()->create(); + $editor->saveAppAuthenticationSecret('JBSWY3DPEHPK3PXP'); + + $this->get('/verwaltung/design/groessen')->assertRedirect(); + $this->actingAs($editor, 'staff')->get('/verwaltung/design/groessen')->assertForbidden(); + $this->actingAs($this->admin(), 'staff')->get('/verwaltung/design/groessen')->assertOk()->assertSee('Größen')->assertSee('Fließtext'); + } + + public function test_the_page_is_listed_in_the_navigation_for_the_administrator(): void + { + $this->actingAs($this->admin(), 'staff')->get('/verwaltung/design/groessen')->assertOk() + ->assertSee('Design') + ->assertSee(DesignGroessen::getUrl()); + } + + public function test_the_form_shows_the_active_values_and_saves_changes_with_one_action(): void + { + $component = Livewire::actingAs($this->admin(), 'staff')->test(DesignGroessen::class); + + $component->assertSet('werte.body', 17)->assertSet('werte.width', 1312); + $this->assertFalse($component->instance()->geaendert()); + + $component->set('werte.body', '18')->set('werte.media', '300'); + $this->assertTrue($component->instance()->geaendert()); + $this->assertSame(DesignScale::defaults(), DesignSettings::values(), 'Offene Eingaben speichern nichts.'); + + $component->call('speichern')->assertHasNoErrors(); + + $this->assertSame(18, DesignSettings::values()['body']); + $this->assertSame(300, DesignSettings::values()['media']); + $this->assertFalse($component->instance()->geaendert()); + } + + public function test_invalid_values_show_messages_and_are_not_saved(): void + { + $component = Livewire::actingAs($this->admin(), 'staff')->test(DesignGroessen::class) + ->set('werte.body', '99') + ->set('werte.h2', '') + ->call('speichern'); + + $this->assertArrayHasKey('body', $component->get('fehler')); + $this->assertArrayHasKey('h2', $component->get('fehler')); + $this->assertSame(0, SiteSetting::query()->count()); + $component->assertSee('mindestens 16 px', false)->assertSee('höchstens 20 px', false); + } + + public function test_restoring_the_defaults_needs_a_confirmation_and_clears_the_stored_values(): void + { + DesignSettings::save([...DesignScale::defaults(), 'body' => 18, 'section' => 64]); + + $component = Livewire::actingAs($this->admin(), 'staff')->test(DesignGroessen::class) + ->assertSet('werte.section', 64) + ->call('askConfirmation', 'standard'); + + $this->assertSame(64, DesignSettings::values()['section'], 'Erst die Bestätigung wirkt.'); + $component->assertSee('Standardwerte wiederherstellen?', false)->call('confirmConfirmation'); + + $this->assertSame(DesignScale::defaults(), DesignSettings::values()); + $component->assertSet('werte.section', 48)->assertSet('bestaetigung', null); + } + + public function test_cancelling_the_confirmation_keeps_everything(): void + { + DesignSettings::save([...DesignScale::defaults(), 'body' => 18]); + + Livewire::actingAs($this->admin(), 'staff')->test(DesignGroessen::class) + ->call('askConfirmation', 'standard') + ->call('cancelConfirmation') + ->assertSet('bestaetigung', null); + + $this->assertSame(18, DesignSettings::values()['body']); + } + + public function test_discarding_returns_the_inputs_to_the_active_state_without_saving(): void + { + $component = Livewire::actingAs($this->admin(), 'staff')->test(DesignGroessen::class) + ->set('werte.h1', '44') + ->call('askConfirmation', 'verwerfen') + ->call('confirmConfirmation') + ->assertSet('werte.h1', 40); + + $this->assertSame(0, SiteSetting::query()->count()); + $this->assertFalse($component->instance()->geaendert()); + } + + public function test_a_redakteur_cannot_call_the_page_component(): void + { + $editor = User::factory()->redakteur()->create(); + + Livewire::actingAs($editor, 'staff')->test(DesignGroessen::class)->assertForbidden(); + } +} diff --git a/tests/TestCase.php b/tests/TestCase.php index 388f6b5..0e09dcc 100644 --- a/tests/TestCase.php +++ b/tests/TestCase.php @@ -2,6 +2,7 @@ namespace Tests; +use App\Domain\Design\DesignSettings; use Illuminate\Foundation\Testing\TestCase as BaseTestCase; abstract class TestCase extends BaseTestCase @@ -11,5 +12,6 @@ protected function setUp(): void parent::setUp(); $this->withoutVite(); + DesignSettings::flush(); } } diff --git a/tests/Unit/DesignScaleTest.php b/tests/Unit/DesignScaleTest.php new file mode 100644 index 0000000..2289d57 --- /dev/null +++ b/tests/Unit/DesignScaleTest.php @@ -0,0 +1,95 @@ +assertSame([ + 'body' => 17, 'h1' => 40, 'h2' => 28, 'display' => 52, 'space' => 8, + 'section' => 48, 'card_pad' => 20, 'header' => 80, 'width' => 1312, 'media' => 320, + ], DesignScale::defaults()); + $this->assertSame([], DesignScale::errors(DesignScale::defaults())); + } + + public function test_every_default_lies_within_its_range(): void + { + foreach (DesignScale::PARAMETERS as $key => $p) { + $this->assertGreaterThanOrEqual($p['min'], $p['default'], $key); + $this->assertLessThanOrEqual($p['max'], $p['default'], $key); + $this->assertContains($p['group'], DesignScale::GROUPS, $key); + } + } + + public function test_the_defaults_equal_the_values_in_the_stylesheet(): void + { + $css = file_get_contents(dirname(__DIR__, 2).'/resources/css/tokens.css'); + $this->assertNotFalse($css); + preg_match_all('/--ds-([a-z0-9-]+):\s*(\d+);/', $css, $found, PREG_SET_ORDER); + $declared = []; + + foreach ($found as [, $name, $value]) { + $declared[str_replace('-', '_', $name)] = (int) $value; + } + + $this->assertSame(DesignScale::defaults(), $declared, 'tokens.css (Block Größenskala) und DesignScale::PARAMETERS müssen dieselben Standardwerte haben.'); + } + + public function test_values_outside_the_ranges_are_rejected_with_a_message_per_field(): void + { + $errors = DesignScale::errors([...DesignScale::defaults(), 'body' => 12, 'width' => 3000, 'media' => 'abc', 'space' => '']); + + $this->assertEqualsCanonicalizing(['body', 'width', 'media', 'space'], array_keys($errors)); + $this->assertStringContainsString('mindestens 16 px', $errors['body']); + $this->assertStringContainsString('höchstens 1600 px', $errors['width']); + $this->assertStringContainsString('ganze Zahl', $errors['media']); + $this->assertStringContainsString('Bitte einen Wert', $errors['space']); + } + + public function test_the_order_of_the_type_sizes_is_enforced(): void + { + $this->assertArrayHasKey('h2', DesignScale::errors([...DesignScale::defaults(), 'body' => 20, 'h2' => 24])); + $this->assertArrayHasKey('h1', DesignScale::errors([...DesignScale::defaults(), 'h2' => 36, 'h1' => 38])); + $this->assertArrayHasKey('display', DesignScale::errors([...DesignScale::defaults(), 'h1' => 50, 'display' => 44])); + $this->assertSame([], DesignScale::errors([...DesignScale::defaults(), 'body' => 18, 'h2' => 24, 'h1' => 30, 'display' => 36])); + } + + public function test_form_strings_are_accepted_as_numbers(): void + { + $input = array_map('strval', DesignScale::defaults()); + + $this->assertSame([], DesignScale::errors($input)); + $this->assertSame([], DesignScale::errors([...$input, 'body' => '18'])); + $this->assertNotSame([], DesignScale::errors([...$input, 'body' => '17.5']), 'Nur ganze Pixel.'); + } + + public function test_only_deviating_values_become_variables(): void + { + $this->assertSame('', DesignScale::css(DesignScale::defaults())); + $this->assertSame(':root{--ds-body:18;--ds-card-pad:24;}', DesignScale::css([...DesignScale::defaults(), 'body' => 18, 'card_pad' => 24])); + } + + public function test_the_stylesheet_block_contains_only_validated_numbers_of_known_keys(): void + { + $css = DesignScale::css([...DesignScale::defaults(), 'body' => 18, 'evil' => '};body{display:none}', 'h1' => 99999]); + + $this->assertSame(':root{--ds-body:18;}', $css, 'Unbekannte Schlüssel und Werte außerhalb des Bereichs werden nie ausgegeben.'); + } + + public function test_reading_stored_values_never_fails_and_falls_back_to_the_defaults(): void + { + $this->assertSame(DesignScale::defaults(), DesignScale::read(null)); + $this->assertSame(DesignScale::defaults(), DesignScale::read('kaputt')); + $this->assertSame(DesignScale::defaults(), DesignScale::read(['body' => 99]), 'Außerhalb des Bereichs: Standard.'); + $this->assertSame(DesignScale::defaults(), DesignScale::read(['h1' => 30, 'h2' => 29]), 'Falsche Reihenfolge: Standard.'); + $this->assertSame([...DesignScale::defaults(), 'body' => 18], DesignScale::read(['body' => 18, 'unbekannt' => 5, 'h1' => 'x']), 'Fehlendes und Fremdes wird ignoriert.'); + $this->assertSame([...DesignScale::defaults(), 'body' => 18], DesignScale::read(['body' => '18'])); + } +} diff --git a/tests/Unit/NginxConfigTest.php b/tests/Unit/NginxConfigTest.php index c5c6a06..27ae5db 100644 --- a/tests/Unit/NginxConfigTest.php +++ b/tests/Unit/NginxConfigTest.php @@ -7,16 +7,151 @@ /** * Der Web-Container (nginx) muss den App-Container zur Laufzeit über Dockers DNS finden. Mit einer festen Adresse * beim Start antwortete Prod nach einem erneuten Deploy-Lauf mit 502 (App neu erzeugt, nginx nicht). + * + * Außerdem leitet er die Alias-Adressen auf https://lara-und-felix.de weiter. Das Verhalten wurde mit nginx selbst + * geprüft (Ergebnis in docs/betrieb/DEPLOYMENT.md). Diese Tests sichern die Zusagen der Konfiguration gegen + * versehentliche Änderungen, denn im CI-Container läuft kein nginx. */ class NginxConfigTest extends TestCase { + private function config(): string + { + return (string) file_get_contents(dirname(__DIR__, 2).'/docker/nginx/default.conf'); + } + + /** + * Zeilen der Weiterleitungs-map in der Reihenfolge der Datei (nginx wertet sie in dieser Reihenfolge aus). + * + * @return list + */ + private function redirectMap(): array + { + $found = preg_match('/^map\s+"[^"]*"\s+\$luf_canonical_redirect\s*\{(.*?)^\}/ms', $this->config(), $match); + $this->assertSame(1, $found, 'Die map $luf_canonical_redirect fehlt.'); + + return array_values(array_filter(array_map('trim', explode("\n", $match[1])))); + } + + /** + * @return list Zeilen der map, die weiterleiten (Wert 1) + */ + private function redirectRules(): array + { + return array_values(array_filter($this->redirectMap(), fn (string $line) => str_ends_with($line, '" 1;'))); + } + public function test_nginx_resolves_the_app_container_at_request_time(): void { - $config = (string) file_get_contents(dirname(__DIR__, 2).'/docker/nginx/default.conf'); + $config = $this->config(); $this->assertMatchesRegularExpression('/^\s*resolver\s+127\.0\.0\.11\b[^;]*valid=\d+s[^;]*;/m', $config); $this->assertMatchesRegularExpression('/^\s*set\s+\$php_upstream\s+app:9000;/m', $config); $this->assertMatchesRegularExpression('/^\s*fastcgi_pass\s+\$php_upstream;/m', $config); $this->assertDoesNotMatchRegularExpression('/^\s*fastcgi_pass\s+app:9000;/m', $config); } + + public function test_nginx_keeps_the_fastcgi_and_timeout_settings(): void + { + $config = $this->config(); + + $this->assertMatchesRegularExpression('/^\s*fastcgi_read_timeout\s+3600s;/m', $config); + $this->assertMatchesRegularExpression('/^\s*fastcgi_send_timeout\s+3600s;/m', $config); + $this->assertMatchesRegularExpression('/^\s*client_max_body_size\s+2048m;/m', $config); + $this->assertMatchesRegularExpression('/^\s*fastcgi_param\s+HTTP_X_FORWARDED_PROTO\s+\$forwarded_proto;/m', $config); + $this->assertStringContainsString('try_files $uri $uri/ /index.php?$query_string;', $config); + $this->assertStringContainsString('location ~ /\.(?!well-known) {', $config); + } + + public function test_alias_hosts_are_redirected_to_the_fixed_canonical_domain(): void + { + $config = $this->config(); + + $this->assertStringContainsString('if ($luf_canonical_redirect = 1) {', $config); + $this->assertStringContainsString('return 301 https://lara-und-felix.de$request_uri;', $config, 'Fest verdrahtetes Ziel, Pfad und Query-String aus $request_uri.'); + $this->assertSame(1, preg_match_all('/^\s*return\s+30\d\s/m', $config), 'Es gibt genau eine Weiterleitung.'); + $this->assertSame(2, preg_match_all('/^\s*return\s+\d{3}\b/m', $config), 'Nur Weiterleitung und Sperre antworten selbst.'); + $this->assertDoesNotMatchRegularExpression('/return\s+30\d\s+[^;]*\$(host|http_host|http_x_forwarded_host|scheme)/', $config, 'Das Ziel darf nicht aus Anfragewerten entstehen.'); + } + + public function test_redirect_rules_cover_both_www_aliases_and_the_http_apex_only(): void + { + $rules = implode("\n", $this->redirectRules()); + + $this->assertCount(3, $this->redirectRules()); + $this->assertStringContainsString('www\.lara-und-felix\.de', $rules); + $this->assertStringContainsString('www\.laraundfelix\.de', $rules); + $this->assertStringContainsString('\|\s*http\s*(,[^|]*)?\|lara-und-felix\.de', $rules, 'Der Apex wird nur bei ausdrücklichem X-Forwarded-Proto http weitergeleitet.'); + $this->assertStringNotContainsString('dev.', $rules, 'dev.laraundfelix.de bleibt unverändert.'); + $this->assertStringNotContainsString('|laraundfelix', $rules, 'laraundfelix.de ohne www übernimmt die STRATO-Weiterleitung.'); + $this->assertStringContainsString('default 0;', implode("\n", $this->redirectMap())); + } + + public function test_only_get_and_head_are_redirected(): void + { + foreach ($this->redirectRules() as $rule) { + $this->assertStringContainsString('"~*^(GET|HEAD)\|', $rule, 'POST (zum Beispiel der Stripe-Webhook) darf kein 301 bekommen: '.$rule); + } + } + + /** + * @return list Zeilen der map, die andere Methoden sperren (Wert 2) + */ + private function blockRules(): array + { + return array_values(array_filter($this->redirectMap(), fn (string $line) => str_ends_with($line, '" 2;'))); + } + + public function test_other_methods_on_the_three_shop_hosts_end_at_nginx_when_proxy_says_http(): void + { + $config = $this->config(); + $rules = $this->blockRules(); + + $this->assertCount(1, $rules); + $rule = $rules[0]; + $this->assertStringStartsWith('"~*^[^|]*\|', $rule, 'Jede Methode, die nicht vorher als GET/HEAD entschieden wurde.'); + $this->assertStringContainsString('\|\s*http\s*(,[^|]*)?\|', $rule, 'Nur bei ausdrücklichem X-Forwarded-Proto http (erster Wert).'); + foreach (['www\.lara-und-felix', 'www\.laraundfelix', '(www\.lara-und-felix|www\.laraundfelix|lara-und-felix)\.de'] as $host) { + $this->assertStringContainsString($host, $rule); + } + $this->assertStringNotContainsString('dev', $rule, 'dev.laraundfelix.de bleibt unverändert.'); + $this->assertStringNotContainsString('https', $rule); + $this->assertMatchesRegularExpression('/^\s*if\s*\(\$luf_canonical_redirect = 2\)\s*\{\s*return\s+403;\s*\}/m', $config, 'Die Sperre antwortet in nginx, bevor die Anfrage Laravel erreicht.'); + $this->assertDoesNotMatchRegularExpression('/\$luf_canonical_redirect = 2\)\s*\{[^}]*(fastcgi_pass|proxy_pass)/', $config); + } + + public function test_block_rule_comes_after_acme_exception_and_the_redirects(): void + { + // nginx nimmt den ersten passenden Regex-Eintrag: Ausnahme, dann GET/HEAD-Weiterleitungen, zuletzt die Sperre. + $values = array_map(fn (string $line) => rtrim(substr($line, (int) strrpos($line, ' ') + 1), ';'), $this->redirectMap()); + + $this->assertSame(['0', '0', '1', '1', '1', '2'], $values, 'Reihenfolge: default, ACME, drei Weiterleitungen, Sperre.'); + } + + public function test_acme_challenge_is_excluded_before_any_redirect_rule(): void + { + $acme = null; + $firstRedirect = null; + foreach ($this->redirectMap() as $index => $line) { + if ($acme === null && str_contains($line, '/\.well-known/acme-challenge/') && str_ends_with($line, '" 0;')) { + $acme = $index; + } + if ($firstRedirect === null && (str_ends_with($line, '" 1;') || str_ends_with($line, '" 2;'))) { + $firstRedirect = $index; + } + } + + $this->assertNotNull($acme, 'Die ACME-Ausnahme fehlt.'); + $this->assertNotNull($firstRedirect); + $this->assertLessThan($firstRedirect, $acme, 'nginx wertet map-Einträge der Reihe nach aus: die Ausnahme muss vorn stehen.'); + } + + public function test_redirect_decision_uses_forwarded_headers_and_never_the_local_scheme(): void + { + $config = $this->config(); + + $this->assertStringContainsString('map "$request_method|$http_x_forwarded_proto|$luf_public_host|$uri" $luf_canonical_redirect {', $config); + $this->assertStringContainsString('map $http_x_forwarded_host $luf_forwarded_host {', $config); + $this->assertMatchesRegularExpression('/^\s*""\s+\$host;/m', $config, 'Ohne X-Forwarded-Host gilt der Host-Header.'); + $this->assertStringNotContainsString('$scheme|', $config, 'Ohne X-Forwarded-Proto darf nie weitergeleitet werden (direkter Zugriff, Health-Check).'); + } }