Files
laraundfelix/app/Filament/Support/SectionEditor.php
LarsandClaude Opus 5.5 0bfb53463a
CI Feature / test (push) Successful in 41s
Deploy Test / test (push) Successful in 37s
Deploy Test / deploy (push) Successful in 33s
Führe einen gemeinsamen Layoutvertrag ein und integriere die Premium-Widgets.
Layoutvertrag (ADR-38) in der bestehenden Registry: Jede Widget-Art
erklärt zulässige Rasterbreiten (supportedUnits), Höhen aus einem
gemeinsamen Vokabular (heights, gespeichert als settings.height),
Darstellungsmodi und Verhalten bei wenig Platz. Unzulässige Breiten
werden beim Speichern verständlich abgewiesen; Höhe „fill“ streckt
den Handlungsaufruf auf die Abschnittszeile.

Premium-Widgets nach Brand-UI-Kit v1.6:
- hero Version 2: photo_split/editorial_solid, Höhen compact/normal/
  large, Label, Überschriftenebene, Akzent, Bildfokus in Prozent, zwei
  Schaltflächen; nur 3 oder 4 Einheiten. Upgrade aus Version 1.
- image_text Version 3: Fläche cream/clear/navy, Höhen compact/normal/
  spacious, Label, zwei Schaltflächen, Bildfokus; 1 bis 4 Einheiten.
  Upgrade aus Version 2 (format entfällt, Fokus in Prozent).
- Kit-CSS ersetzt das bisherige Hero- und Bild-und-Text-CSS; der
  Randlos-Mechanismus der Designiteration 1 entfällt.

Editor: Reiter Inhalt/Medien/Darstellung aus der Registry, Auswahl-
knöpfe mit Symbolen, Schieberegler für den Bildfokus und eine Live-
Vorschau im Dialog mit demselben Renderer in wählbarer Platzbreite.

Tests bewusst angepasst: Einstieg braucht jetzt 3 oder 4 Einheiten
(vorher Mindestbreite 2), image_text ist Version 3, Klassen der neuen
Ansichten; die Hero-/Bild-Tests der Designiteration 1 sind durch
CmsPremiumWidgetsTest ersetzt.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 10:20:09 +01:00

548 lines
23 KiB
PHP

<?php
namespace App\Filament\Support;
use App\Domain\Cms\Sections\PageSections;
use App\Domain\Cms\Sections\SectionLayouts;
use App\Domain\Cms\Sections\SectionStyle;
use App\Domain\Cms\Widgets\Support\PublicMedia;
use App\Domain\Cms\Widgets\WidgetRegistry;
use Filament\Actions\Action;
use Filament\Forms\Components\FileUpload;
use Filament\Forms\Components\Hidden;
use Filament\Forms\Components\Repeater;
use Filament\Forms\Components\Select;
use Filament\Forms\Components\ToggleButtons;
use Filament\Notifications\Notification;
use Filament\Schemas\Components\Group;
use Filament\Schemas\Components\Section;
use Filament\Schemas\Components\Utilities\Get;
use Filament\Schemas\Components\Utilities\Set;
use Illuminate\Support\HtmlString;
use Illuminate\Support\Str;
use Livewire\Features\SupportFileUploads\TemporaryUploadedFile;
/**
* Seiteneditor für Abschnitte und Slots.
*
* Aufbau: Abschnitte (Repeater) → Raster (grafische Auswahl) → Gestaltung (eingeklappt) → Plätze (Repeater im
* Rasterverhältnis) → je Platz ein Widget (Builder mit höchstens einem Eintrag, Auswahl aus dem Widget-Register).
* Abschnittseinstellungen stehen im Abschnitt, Widget-Einstellungen im Widget-Dialog: eine Dialogebene.
*
* Formularzustand eines Abschnitts: {id, layout, style: {...}, slots: {uuid: {widget: {uuid: Builder-Eintrag}}}}.
*/
class SectionEditor
{
public static function repeater(string $name = 'sections'): Repeater
{
return Repeater::make($name)
->label('Abschnitte')
->hiddenLabel()
->schema(self::sectionSchema())
->itemLabel(fn (array $state, ?int $index): string => self::sectionLabel($state, $index))
->addActionLabel('Abschnitt hinzufügen')
->addBetweenActionLabel('Abschnitt hier einfügen')
->defaultItems(0)
->reorderableWithButtons()
->reorderableWithDragAndDrop()
->cloneable()
->collapsible()
->deletable()
->maxItems(PageSections::MAX_SECTIONS)
->cloneAction(fn (Action $action): Action => $action
->tooltip('Abschnitt duplizieren')
->action(function (array $arguments, Repeater $component): void {
// Die Kopie steht direkt hinter dem Original (Filament hängt sie sonst ans Seitenende).
$component->rawState(self::insertCopyAfter($component->getRawState() ?? [], (string) $arguments['item'], (string) $component->generateUuid()));
$component->callAfterStateUpdated();
$component->shouldPartiallyRenderAfterActionsCalled() ? $component->partiallyRender() : null;
}))
->deleteAction(fn (Action $action): Action => $action
->tooltip('Abschnitt löschen')
->requiresConfirmation()
->modalHeading('Abschnitt löschen?')
->modalDescription('Der Abschnitt und die Widgets darin werden aus dem Entwurf entfernt. Bereits gespeicherte Revisionen bleiben erhalten.')
->modalSubmitActionLabel('Löschen'))
->moveUpAction(fn (Action $action): Action => $action->tooltip('Abschnitt nach oben'))
->moveDownAction(fn (Action $action): Action => $action->tooltip('Abschnitt nach unten'))
->reorderAction(fn (Action $action): Action => $action->tooltip('Abschnitt ziehen'))
->collapseAction(fn (Action $action): Action => $action->tooltip('Abschnitt einklappen'))
->expandAction(fn (Action $action): Action => $action->tooltip('Abschnitt aufklappen'))
->extraAttributes(['class' => 'luf-sections'])
->columnSpanFull();
}
/**
* @return list<mixed>
*/
private static function sectionSchema(): array
{
return [
Hidden::make('id'),
ToggleButtons::make('layout')
->label('Raster')
->options(self::layoutOptions())
->default(SectionLayouts::DEFAULT)
->required()
->inline()
->live()
->disableOptionWhen(fn (string $value, Get $get): bool => self::filledCount($get('slots')) > SectionLayouts::slotCount($value))
->helperText(fn (Get $get): ?string => self::filledCount($get('slots')) > 1
? 'Raster mit weniger Plätzen als eingesetzten Widgets sind gesperrt. Entfernen oder verschieben Sie zuerst ein Widget; beim Wechsel geht kein Widget verloren.'
: null)
->afterStateUpdated(function (?string $state, Get $get, Set $set): void {
$set('slots', self::arrangeSlots($get('slots'), $state ?? SectionLayouts::DEFAULT));
})
->extraAttributes(['class' => 'luf-layout-picker']),
Section::make('Gestaltung des Abschnitts')
->description(fn (Get $get): string => SectionStyle::summary(is_array($get('style')) ? $get('style') : []))
->icon('heroicon-o-swatch')
->collapsible()
->collapsed()
->compact()
->schema([
Group::make(self::styleFields())
->statePath('style')
->columns(['default' => 1, 'md' => 2, 'xl' => 4]),
]),
Repeater::make('slots')
->label('Plätze im Raster')
->hiddenLabel()
->schema([
WidgetEditor::slotBuilder('widget'),
])
->addable(false)
->deletable(false)
->reorderableWithDragAndDrop()
->reorderableWithButtons(false)
->reorderAction(fn (Action $action): Action => $action->tooltip('Widget auf einen anderen Platz ziehen'))
->itemLabel(fn (array $state, ?int $index, Get $get): string => self::slotLabel($state, $index, $get('layout')))
->default(fn (): array => self::arrangeSlots([], SectionLayouts::DEFAULT))
->extraAttributes(fn (Get $get): array => [
'class' => 'luf-slots',
'style' => '--luf-slot-cols: '.self::editorColumns($get('layout')),
]),
];
}
/**
* @return list<mixed>
*/
private static function styleFields(): array
{
return [
Select::make('background')
->label('Hintergrund')
->options(SectionStyle::BACKGROUNDS)
->default('default')
->selectablePlaceholder(false)
->live(),
Select::make('width')
->label('Breite')
->options(SectionStyle::WIDTHS)
->default('standard')
->selectablePlaceholder(false)
->helperText('Ein Hintergrund reicht immer über die ganze Bildschirmbreite.'),
Select::make('spacing')
->label('Abstand oben und unten')
->options(SectionStyle::SPACINGS)
->default('normal')
->selectablePlaceholder(false),
Select::make('divider')
->label('Trenner zum nächsten Abschnitt')
->options(SectionStyle::DIVIDERS)
->default('none')
->selectablePlaceholder(false),
Select::make('image')
->label('Hintergrundbild: vorhandenes Bild')
->options(fn (): array => PublicMedia::imageOptions())
->searchable()
->placeholder('Bitte wählen')
->helperText('Nur Bilder aus dem öffentlichen Website-Bereich. Geschützte Filmbilder sind hier nicht wählbar.')
->visible(fn (Get $get): bool => $get('background') === 'image')
->columnSpan(['default' => 1, 'md' => 2]),
FileUpload::make('_upload')
->label('Hintergrundbild: neu hochladen')
->disk('cms_incoming')
->directory('cms')
->image()
->maxSize(8192)
->acceptedFileTypes(['image/jpeg', 'image/png', 'image/webp'])
->getUploadedFileNameForStorageUsing(fn (TemporaryUploadedFile $file): string => Str::slug(pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME)).'-'.Str::lower(Str::random(6)).'.'.$file->guessExtension())
->helperText('Ersetzt die Auswahl links. Nur Bilder mit geklärter Veröffentlichungsfreigabe hochladen.')
->visible(fn (Get $get): bool => $get('background') === 'image')
->columnSpan(['default' => 1, 'md' => 2]),
Select::make('focus')
->label('Bildausschnitt (Fokuspunkt)')
->options(SectionStyle::FOCUS)
->default('center')
->selectablePlaceholder(false)
->helperText('Dieser Bereich bleibt auf schmalen Bildschirmen sichtbar.')
->visible(fn (Get $get): bool => $get('background') === 'image'),
Select::make('overlay')
->label('Überlagerung')
->options(SectionStyle::OVERLAYS)
->default('light')
->selectablePlaceholder(false)
->helperText('Sorgt für lesbaren Text auf dem Bild.')
->visible(fn (Get $get): bool => $get('background') === 'image'),
];
}
/**
* Gespeicherte Abschnitte (PageSections::read) als Formularzustand.
*
* @param list<array<string, mixed>> $sections
* @return list<array<string, mixed>>
*/
public static function toEditorState(array $sections): array
{
$state = [];
foreach ($sections as $section) {
$slots = [];
foreach ($section['slots'] as $widget) {
$slots[(string) Str::uuid()] = [
'widget' => is_array($widget) ? self::keyed(WidgetEditor::toBuilderState([$widget])) : [],
];
}
$state[] = [
'id' => $section['id'] ?? (string) Str::uuid(),
'layout' => $section['layout'],
'style' => SectionStyle::fromStored($section['style'] ?? []),
'slots' => $slots,
];
}
return $state;
}
/**
* Formularzustand als Abschnitte für PageService::saveRevision().
*
* @param array<int|string, mixed>|null $state
* @return list<array<string, mixed>>
*/
public static function fromEditorState(?array $state): array
{
$sections = [];
foreach (array_values($state ?? []) as $section) {
if (! is_array($section)) {
continue;
}
$slots = [];
foreach (array_values(is_array($section['slots'] ?? null) ? $section['slots'] : []) as $slot) {
$items = is_array($slot['widget'] ?? null) ? $slot['widget'] : [];
$slots[] = $items === [] ? null : (WidgetEditor::fromBuilderState($items)[0] ?? null);
}
$sections[] = [
'id' => $section['id'] ?? null,
'layout' => $section['layout'] ?? SectionLayouts::DEFAULT,
'style' => is_array($section['style'] ?? null) ? $section['style'] : [],
'slots' => $slots,
];
}
return $sections;
}
/**
* Übersetzt Fehlerschlüssel aus PageSections ("sections.2.slots.1.data.heading") in Formularpfade.
* Widget-Fehler stehen zusätzlich als Zusammenfassung am Platzraster des Abschnitts, weil die Widget-Felder
* nach dem Schließen des Dialogs nicht sichtbar sind.
*
* @param array<string, mixed> $errors
* @param array<int|string, mixed> $state roher Formularzustand der Abschnitte
* @return array<string, mixed>
*/
public static function mapErrors(array $errors, array $state, string $statePath = 'data.sections'): array
{
$registry = app(WidgetRegistry::class);
$sectionKeys = array_keys($state);
$mapped = [];
foreach ($errors as $key => $messages) {
$messages = (array) $messages;
if (preg_match('/^sections\.(\d+)(?:\.(.*))?$/', (string) $key, $match) !== 1 || ! isset($sectionKeys[(int) $match[1]])) {
$mapped[$key === 'sections' ? $statePath : 'data.'.$key] = $messages;
continue;
}
$sectionKey = $sectionKeys[(int) $match[1]];
$sectionPath = "$statePath.$sectionKey";
$rest = $match[2] ?? '';
if (preg_match('/^slots\.(\d+)(?:\.(.*))?$/', $rest, $slotMatch) === 1) {
$slotKeys = array_keys(is_array($state[$sectionKey]['slots'] ?? null) ? $state[$sectionKey]['slots'] : []);
$slotKey = $slotKeys[(int) $slotMatch[1]] ?? null;
$field = $slotMatch[2] ?? '';
$position = (int) $slotMatch[1] + 1;
$widgetItems = $slotKey !== null ? ($state[$sectionKey]['slots'][$slotKey]['widget'] ?? []) : [];
$widgetKey = is_array($widgetItems) ? array_key_first($widgetItems) : null;
$type = $widgetKey !== null ? ($widgetItems[$widgetKey]['type'] ?? null) : null;
$label = $registry->has($type) ? $registry->get($type)->label() : 'Widget';
$summary = $mapped["$sectionPath.slots"] ?? [];
foreach ($messages as $message) {
$summary[] = "Platz $position ($label): $message";
}
$mapped["$sectionPath.slots"] = array_values(array_unique($summary));
if ($slotKey !== null && $widgetKey !== null && $field !== '' && $field !== 'units') {
$field = preg_replace('/\.\d+\..*$/', '', $field);
$mapped["$sectionPath.slots.$slotKey.widget.$widgetKey.data.$field"] = $messages;
}
continue;
}
$mapped[$rest === '' ? $sectionPath : "$sectionPath.$rest"] = $messages;
}
return $mapped;
}
/**
* Formularfehler aus Widget-Dialogen ("data.sections.{uuid}.slots.{uuid}.widget.{uuid}.data.data.feld") in
* Schlüssel des Abschnittsmodells ("sections.N.slots.M.data.feld") übersetzen.
*
* @param array<string, mixed> $errors
* @param array<int|string, mixed> $state
* @return array<string, list<string>>
*/
public static function sectionErrorsFromForm(array $errors, array $state, string $statePath = 'data.sections'): array
{
$sectionKeys = array_flip(array_map('strval', array_keys($state)));
$translated = [];
$pattern = '/^'.preg_quote($statePath, '/').'\.([^.]+)\.slots\.([^.]+)\.widget\.[^.]+\.data\.(.+)$/';
foreach ($errors as $key => $messages) {
if (preg_match($pattern, (string) $key, $match) !== 1 || ! isset($sectionKeys[$match[1]])) {
continue;
}
$slotKeys = array_flip(array_map('strval', array_keys(is_array($state[$match[1]]['slots'] ?? null) ? $state[$match[1]]['slots'] : [])));
if (! isset($slotKeys[$match[2]])) {
continue;
}
$translated['sections.'.$sectionKeys[$match[1]].'.slots.'.$slotKeys[$match[2]].'.'.$match[3]] = array_values((array) $messages);
}
return $translated;
}
/**
* Sichtbare Meldung mit Abschnittsnummer, Platz und Widget-Art.
*
* @param array<string, list<string>> $errors
* @param array<int|string, mixed> $state
*/
public static function notifyErrors(array $errors, array $state): void
{
$registry = app(WidgetRegistry::class);
$sections = array_values($state);
$lines = [];
foreach ($errors as $key => $messages) {
$text = implode(' ', (array) $messages);
if (preg_match('/^sections\.(\d+)(?:\.slots\.(\d+))?/', (string) $key, $match) === 1) {
$line = 'Abschnitt '.((int) $match[1] + 1);
if (isset($match[2])) {
$slots = array_values(is_array($sections[(int) $match[1]]['slots'] ?? null) ? $sections[(int) $match[1]]['slots'] : []);
$items = $slots[(int) $match[2]]['widget'] ?? [];
$type = is_array($items) && $items !== [] ? (array_values($items)[0]['type'] ?? null) : null;
$line .= ', Platz '.((int) $match[2] + 1).($registry->has($type) ? ' ('.$registry->get($type)->label().')' : '');
}
$lines[] = $line.': '.$text;
} else {
$lines[] = $text;
}
}
Notification::make()
->title('Nicht gespeichert')
->body(implode("\n", array_unique($lines)))
->danger()
->persistent()
->send();
}
/**
* Ordnet Plätze für ein neues Raster: Widgets behalten ihre Reihenfolge, leere Plätze entfallen zuerst.
* Es wird nie ein Widget entfernt; passen nicht alle Widgets, bleiben überzählige Plätze bestehen
* (die Auswahl solcher Raster ist im Editor gesperrt, das Speichern weist sie ab).
*
* @param mixed $slots roher Zustand {uuid: {widget: {...}}}
* @return array<string, array{widget: array<string, mixed>}>
*/
public static function arrangeSlots(mixed $slots, string $layout): array
{
$slots = is_array($slots) ? $slots : [];
$count = SectionLayouts::slotCount(SectionLayouts::has($layout) ? $layout : SectionLayouts::DEFAULT);
if (count($slots) === $count) {
return $slots;
}
$filled = array_filter($slots, fn ($slot): bool => self::slotHasWidget($slot));
if (count($slots) < $count) {
$arranged = $slots;
} else {
// Leere Plätze am Ende zuerst entfernen, dann übrige leere Plätze, bis die Zahl passt.
$arranged = $slots;
foreach (array_reverse(array_keys($slots)) as $key) {
if (count($arranged) <= $count) {
break;
}
if (! self::slotHasWidget($slots[$key])) {
unset($arranged[$key]);
}
}
$arranged = count($arranged) > $count ? $filled : $arranged;
}
while (count($arranged) < $count) {
$arranged[(string) Str::uuid()] = ['widget' => []];
}
return $arranged;
}
/**
* Fügt die Kopie eines Abschnitts direkt hinter dem Original ein. Kennungen bleiben gleich; beim Speichern
* behält das Original seine Kennungen und die Kopie erhält neue.
*
* @param array<string, mixed> $items
* @return array<string, mixed>
*/
public static function insertCopyAfter(array $items, string $key, string $newKey): array
{
if (! array_key_exists($key, $items)) {
return $items;
}
$result = [];
foreach ($items as $itemKey => $item) {
$result[$itemKey] = $item;
if ((string) $itemKey === $key) {
$result[$newKey] = $item;
}
}
return $result;
}
public static function filledCount(mixed $slots): int
{
return count(array_filter(is_array($slots) ? $slots : [], fn ($slot): bool => self::slotHasWidget($slot)));
}
private static function slotHasWidget(mixed $slot): bool
{
return is_array($slot) && is_array($slot['widget'] ?? null) && $slot['widget'] !== [];
}
/**
* @return array<string, HtmlString>
*/
private static function layoutOptions(): array
{
$options = [];
foreach (SectionLayouts::UNITS as $key => $units) {
$options[$key] = new HtmlString(
'<span class="luf-layout-option">'.SectionLayouts::schematicSvg($key)
.'<span class="luf-layout-option-text">'.e(SectionLayouts::short($key)).'</span>'
.'<span class="fi-sr-only">'.e(SectionLayouts::LABELS[$key]).'</span></span>'
);
}
return $options;
}
/**
* Spaltenverhältnis der Plätze im Editor; entspricht dem Desktop-Raster der Website.
*/
private static function editorColumns(mixed $layout): string
{
$units = SectionLayouts::units(SectionLayouts::has($layout) ? $layout : SectionLayouts::DEFAULT);
return implode(' ', array_map(fn (int $unit): string => "minmax(0, {$unit}fr)", $units));
}
/**
* @param array<string, mixed> $state
*/
private static function sectionLabel(array $state, ?int $index): string
{
$layout = SectionLayouts::has($state['layout'] ?? null) ? $state['layout'] : SectionLayouts::DEFAULT;
$registry = app(WidgetRegistry::class);
$names = [];
foreach (is_array($state['slots'] ?? null) ? $state['slots'] : [] as $slot) {
$items = is_array($slot['widget'] ?? null) ? $slot['widget'] : [];
$type = $items !== [] ? (array_values($items)[0]['type'] ?? null) : null;
if ($registry->has($type)) {
$names[] = $registry->get($type)->label();
}
}
$label = 'Abschnitt '.(($index ?? 0) + 1).' · Raster '.SectionLayouts::short($layout)
.' · '.SectionStyle::summary(is_array($state['style'] ?? null) ? $state['style'] : []);
return $names === [] ? $label.' · noch leer' : $label.' · '.implode(', ', $names);
}
/**
* @param array<string, mixed> $state
*/
private static function slotLabel(array $state, ?int $index, mixed $layout): string
{
$layout = SectionLayouts::has($layout) ? $layout : SectionLayouts::DEFAULT;
$units = SectionLayouts::units($layout);
$position = $index ?? 0;
$slotUnits = $units[$position] ?? null;
if ($slotUnits === null) {
return 'Platz '.($position + 1).' · außerhalb des Rasters: Widget entfernen oder Raster mit mehr Plätzen wählen';
}
$label = 'Platz '.($position + 1).' · '.$slotUnits.' '.($slotUnits === 1 ? 'Einheit' : 'Einheiten');
$items = is_array($state['widget'] ?? null) ? $state['widget'] : [];
$type = $items !== [] ? (array_values($items)[0]['type'] ?? null) : null;
$registry = app(WidgetRegistry::class);
if ($registry->has($type) && ! $registry->get($type)->supportsUnits($slotUnits)) {
$label .= ' · passt nicht: „'.$registry->get($type)->label().'“ ist für '.$registry->get($type)->unitsLabel().' Einheiten vorgesehen';
}
return $label;
}
/**
* @param list<array<string, mixed>> $items
* @return array<string, array<string, mixed>>
*/
private static function keyed(array $items): array
{
$keyed = [];
foreach ($items as $item) {
$keyed[(string) Str::uuid()] = $item;
}
return $keyed;
}
}