CI Feature / test (push) Failing after 20s
- Seite → Abschnitte → Plätze → Widgets: sechs Raster mit höchstens vier Einheiten, Hintergrund, Breite, Abstand und Trenner als Aufzählungswerte; je Platz ein Widget aus dem bestehenden Register. Neue Spalte page_revisions.sections (ergänzend); blocks erhält weiterhin alle Widgets in Lesereihenfolge als Rollback-Fassung. - Widgets erhalten Mindest- und Vorzugsbreite; Darstellung über Container-Abfragen. - Editor: Abschnitts-Repeater mit grafischer Rasterauswahl, Plätzen im Rasterverhältnis, breiter Arbeitsfläche, kompakten Vorschauen ohne Bildlaufleiste, Meldungen mit Abschnitt und Platz; Rasterwechsel entfernt nie ein Widget. Seite duplizieren. - Designsystem: Marken- und Bedeutungs-Tokens (vorläufig), gemeinsame Grundkomponenten, Nunito/Source Sans 3 lokal; Mitgliederbereich nutzt dieselben Tokens und die Wortmarke. - Kopfzeile, mobile Navigation, Untermenü (parent_id, ergänzend), Fußbereichsgruppen, vorbereiteter Warenkorbzugang (abgeschaltet). Öffentliche Seiten gleich für alle Besucher. - cms:revert-published als Wiederherstellungsweg vor einem Code-Rollback. Die Editor-Tests der ersten Iteration sind bewusst auf den neuen Formularzustand (sections statt blocks) umgestellt; ihre Prüfungen gelten unverändert für die Widgets. Der Vorschautest erwartet keine anmeldeabhängige Kopfzeile mehr (ADR-32). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
517 lines
21 KiB
PHP
517 lines
21 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'))
|
|
->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;
|
|
}
|
|
|
|
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)->minUnits() > $slotUnits) {
|
|
$label .= ' · zu schmal: „'.$registry->get($type)->label().'“ braucht '.$registry->get($type)->minUnits();
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|