- Meerdere bestanden kiezen of slepen (2 tegelijk, per bestand voortgang en reden bij falen, volgorde van kiezen), uploadlimiet standaard 100 per uur - Volgorde ook met slepen (greepje, toetsenbord), pijltjes blijven - Waarschuwing bij niet-opgeslagen wijzigingen (badge, beforeunload, bevestiging bij navigeren, vergelijking met laatst opgeslagen stand) - Teksten zonder vakjargon, uitleg per onderdeel, formaten en limieten van de host (GET /hero/images/limits) - Shimmer (CSS, reduced-motion) op foto's die nog verwerkt worden Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
506 lines
29 KiB
TypeScript
506 lines
29 KiB
TypeScript
import { useEffect, useMemo, useRef, useState } from 'react';
|
|
import { useFieldArray, useForm, useWatch } from 'react-hook-form';
|
|
import { zodResolver } from '@hookform/resolvers/zod';
|
|
import { useTranslation } from 'react-i18next';
|
|
import { toast } from 'sonner';
|
|
import { ArrowDown, ArrowUp, Crosshair, ImagePlus, Trash2 } from 'lucide-react';
|
|
import { DndContext, KeyboardSensor, PointerSensor, closestCenter, useSensor, useSensors, type DragEndEvent } from '@dnd-kit/core';
|
|
import { SortableContext, sortableKeyboardCoordinates, verticalListSortingStrategy } from '@dnd-kit/sortable';
|
|
import { Badge } from '@/components/ui/badge';
|
|
import { Button } from '@/components/ui/button';
|
|
import { Input } from '@/components/ui/input';
|
|
import { Label } from '@/components/ui/label';
|
|
import { FieldError } from '@/components/ui/FieldError';
|
|
import { FormErrorBanner } from '@/components/ui/FormErrorBanner';
|
|
import { NetworkError, ProblemDetailsError } from '@/lib/api-client';
|
|
import { FocusDialog } from '../components/FocusDialog';
|
|
import { PhotoPlaceholder, ProcessingStatus } from '../components/ProcessingStatus';
|
|
import { SortableSlide } from '../components/SortableSlide';
|
|
import { UnsavedChangesGuard } from '../components/UnsavedChangesGuard';
|
|
import { UploadProgress, type UploadItem } from '../components/UploadProgress';
|
|
import { mediaUrl } from '../lib/media';
|
|
import { fromLocalInput, heroFormSchema, toLocalInput, type HeroFormData } from '../schemas/hero';
|
|
import { useHero, useHeroUploadLimits, useSaveHero, useUploadHeroImage } from '../services/hooks';
|
|
import type { HeroAdminDto, HeroFocusRequest, HeroImageDto, HeroSaveRequest } from '../services/types';
|
|
|
|
const textareaClass =
|
|
'w-full rounded-md border border-input bg-background px-3 py-2 text-sm focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring';
|
|
|
|
function toForm(hero: HeroAdminDto): HeroFormData {
|
|
const buttons = [0, 1].map((i) => ({ label: hero.buttons[i]?.label ?? '', target: hero.buttons[i]?.target ?? '' }));
|
|
return {
|
|
title: hero.title,
|
|
tagline: hero.tagline ?? '',
|
|
lead: hero.lead ?? '',
|
|
display: hero.display,
|
|
buttons,
|
|
isActive: hero.isActive,
|
|
startsAt: toLocalInput(hero.startsAt),
|
|
endsAt: toLocalInput(hero.endsAt),
|
|
slides: hero.slides.map((s) => ({ id: s.id, imageId: s.imageId, alt: s.alt, decorative: s.decorative, isActive: s.isActive })),
|
|
};
|
|
}
|
|
|
|
function toRequest(values: HeroFormData, focusEdits: Record<string, HeroFocusRequest>): HeroSaveRequest {
|
|
return {
|
|
title: values.title,
|
|
tagline: values.tagline || null,
|
|
lead: values.lead || null,
|
|
display: values.display,
|
|
buttons: values.buttons.filter((b) => b.label !== '' && b.target !== ''),
|
|
isActive: values.isActive,
|
|
startsAt: fromLocalInput(values.startsAt),
|
|
endsAt: fromLocalInput(values.endsAt),
|
|
slides: values.slides.map((s) => ({ id: s.id, imageId: s.imageId, alt: s.decorative ? null : s.alt, decorative: s.decorative, isActive: s.isActive })),
|
|
imageFocus: Object.entries(focusEdits).map(([imageId, edit]) => ({ imageId, ...edit })),
|
|
};
|
|
}
|
|
|
|
/** The messages a failed save carries: the field errors of a 400, or a generic text. */
|
|
function serverMessage(error: unknown, generic: string, network: string): string {
|
|
if (error instanceof NetworkError) return network;
|
|
if (error instanceof ProblemDetailsError && error.status === 400) {
|
|
const errors = error.problem.errors;
|
|
if (errors && typeof errors === 'object') {
|
|
const messages = Object.values(errors as Record<string, unknown>).flatMap((v) => (Array.isArray(v) ? v : [v])).filter((v): v is string => typeof v === 'string');
|
|
if (messages.length > 0) return messages.join(' ');
|
|
}
|
|
}
|
|
return generic;
|
|
}
|
|
|
|
/** The most the host accepts for one image (Media:MaxUploadBytes). */
|
|
const MAX_UPLOAD_BYTES = 10 * 1024 * 1024;
|
|
|
|
/**
|
|
* What to tell the administrator when an upload fails: the message of the host when it sent one, a clear text for a
|
|
* refusal by the proxy (413, which has no JSON body) or a rate limit, and a retry hint when the connection broke off.
|
|
*/
|
|
function uploadMessage(error: unknown, t: (key: string, options?: Record<string, unknown>) => string): string {
|
|
if (error instanceof ProblemDetailsError) {
|
|
const message = error.problem.message;
|
|
if (typeof message === 'string' && message !== '') return message;
|
|
if (error.status === 413) return t('hero.upload.tooLarge', { max: MAX_UPLOAD_BYTES / (1024 * 1024) });
|
|
if (error.status === 429) return t('hero.upload.busy');
|
|
return t('errors.generic');
|
|
}
|
|
if (error instanceof NetworkError) return t('hero.upload.interrupted');
|
|
return t('errors.generic');
|
|
}
|
|
|
|
/** The smallest WebP of the wide ratio for a thumbnail; the plain source when there is none. */
|
|
function thumbnail(image: HeroImageDto): string {
|
|
const small = image.variants
|
|
.filter((v) => v.type === 'image/webp' && v.ratio === 'wide')
|
|
.sort((a, b) => a.width - b.width)[0];
|
|
return mediaUrl(small?.url ?? image.src);
|
|
}
|
|
|
|
export function HeroPage() {
|
|
const { t } = useTranslation();
|
|
const { data: hero, isLoading, isError, refetch } = useHero();
|
|
|
|
return (
|
|
<div className="space-y-6" data-testid="hero-page">
|
|
<div className="flex flex-wrap items-center gap-3">
|
|
<h1 className="text-2xl font-semibold" data-testid="hero-title">{t('hero.title')}</h1>
|
|
{hero && (
|
|
<Badge variant={hero.isLive ? 'default' : 'secondary'} data-testid="hero-live-badge">
|
|
{hero.isLive ? t('hero.live') : t('hero.notLive')}
|
|
</Badge>
|
|
)}
|
|
</div>
|
|
<p className="max-w-3xl text-sm text-muted-foreground">{t('hero.intro')}</p>
|
|
<details className="max-w-3xl rounded-md border p-3 text-sm" data-testid="hero-help">
|
|
<summary className="cursor-pointer font-medium">{t('hero.help.heading')}</summary>
|
|
<dl className="mt-3 space-y-2">
|
|
{(['title', 'tagline', 'lead', 'buttons', 'display', 'slides', 'focus', 'schedule'] as const).map((key) => (
|
|
<div key={key}>
|
|
<dt className="font-medium">{t(`hero.help.${key}.name`)}</dt>
|
|
<dd className="text-muted-foreground">{t(`hero.help.${key}.text`)}</dd>
|
|
</div>
|
|
))}
|
|
</dl>
|
|
<p className="mt-3 text-muted-foreground">{t('hero.help.save')}</p>
|
|
</details>
|
|
|
|
{isLoading && <p data-testid="hero-loading">{t('common.loading')}</p>}
|
|
{isError && (
|
|
<div className="space-y-2" data-testid="hero-error">
|
|
<p>{t('errors.generic')}</p>
|
|
<Button variant="outline" onClick={() => void refetch()}>{t('common.retry')}</Button>
|
|
</div>
|
|
)}
|
|
{hero && <ProcessingStatus hero={hero} />}
|
|
{hero && <HeroEditor key={hero.id ?? 'new'} hero={hero} />}
|
|
</div>
|
|
);
|
|
}
|
|
|
|
function HeroEditor({ hero }: { hero: HeroAdminDto }) {
|
|
const { t } = useTranslation();
|
|
const save = useSaveHero();
|
|
const upload = useUploadHeroImage();
|
|
const [serverError, setServerError] = useState<string | null>(null);
|
|
const [uploads, setUploads] = useState<UploadItem[]>([]);
|
|
const [uploading, setUploading] = useState(false);
|
|
const [draggingFiles, setDraggingFiles] = useState(false);
|
|
const nextUploadKey = useRef(0);
|
|
const limits = useHeroUploadLimits().data;
|
|
const [localImages, setLocalImages] = useState<Record<string, HeroImageDto>>({});
|
|
const [focusImageId, setFocusImageId] = useState<string | null>(null);
|
|
// Changed focus points are kept here until the hero is saved: they are sent with the save and dropped when the page is left.
|
|
const [focusEdits, setFocusEdits] = useState<Record<string, HeroFocusRequest>>({});
|
|
const fileInput = useRef<HTMLInputElement>(null);
|
|
|
|
const {
|
|
register,
|
|
handleSubmit,
|
|
control,
|
|
formState: { errors, isDirty },
|
|
reset,
|
|
} = useForm<HeroFormData>({ resolver: zodResolver(heroFormSchema), mode: 'onTouched', defaultValues: toForm(hero) });
|
|
const slides = useFieldArray({ control, name: 'slides' });
|
|
const watchedSlides = useWatch({ control, name: 'slides' }) ?? [];
|
|
|
|
// The images of the saved hero (always current: a change of focus refreshes them) plus the ones uploaded in this session.
|
|
const images = useMemo(() => {
|
|
const map: Record<string, HeroImageDto> = { ...localImages };
|
|
for (const s of hero.slides) map[s.imageId] = s.image;
|
|
return map;
|
|
}, [hero.slides, localImages]);
|
|
|
|
// A focus change counts as unsaved only while it differs from what is saved (applying the old point again is no change).
|
|
const samePoint = (a: unknown, b: unknown) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
|
|
const hasPendingFocus = Object.entries(focusEdits).some(([imageId, edit]) => {
|
|
const saved = images[imageId];
|
|
return !saved || !samePoint(saved.focus, edit.focus) || !samePoint(saved.wideFocus, edit.wide) || !samePoint(saved.tallFocus, edit.tall);
|
|
});
|
|
// The form is compared with the last saved state (react-hook-form keeps it), so a change that is undone no longer counts.
|
|
// Photos still being prepared on the server and the background refresh are not changes of the administrator.
|
|
const hasUnsaved = isDirty || hasPendingFocus;
|
|
useEffect(() => {
|
|
if (!hasUnsaved) return undefined;
|
|
const warn = (event: BeforeUnloadEvent) => {
|
|
event.preventDefault();
|
|
};
|
|
window.addEventListener('beforeunload', warn);
|
|
return () => window.removeEventListener('beforeunload', warn);
|
|
}, [hasUnsaved]);
|
|
|
|
// The image as the dialog shows it: the saved one with a not yet saved change of its focus applied.
|
|
const withPendingFocus = (image: HeroImageDto | null): HeroImageDto | null => {
|
|
const edit = image ? focusEdits[image.id] : undefined;
|
|
return image && edit ? { ...image, focus: edit.focus, wideFocus: edit.wide, tallFocus: edit.tall } : image;
|
|
};
|
|
|
|
// Up to this many files go to the host at the same time; the variants are cut in the background, so an upload itself
|
|
// is quick, and two at a time keeps the memory use of a small server in check.
|
|
const UPLOAD_PARALLEL = 2;
|
|
|
|
const onFiles = async (chosen: FileList | File[] | null) => {
|
|
const files = Array.from(chosen ?? []);
|
|
if (files.length === 0 || uploading) return;
|
|
const maxBytes = limits?.maxUploadBytes ?? MAX_UPLOAD_BYTES;
|
|
const maxMb = Math.round(maxBytes / (1024 * 1024));
|
|
const items: UploadItem[] = files.map((file) => ({ key: nextUploadKey.current++, name: file.name, status: 'waiting' }));
|
|
setUploads(items);
|
|
setUploading(true);
|
|
|
|
const update = (i: number, patch: Partial<UploadItem>) =>
|
|
setUploads((current) => current.map((u) => (u.key === items[i].key ? { ...u, ...patch } : u)));
|
|
|
|
// The images are added to the list in the order they were chosen, whichever upload finishes first.
|
|
const results: (HeroImageDto | 'failed' | undefined)[] = new Array<HeroImageDto | 'failed' | undefined>(files.length).fill(undefined);
|
|
let flushed = 0;
|
|
let cursor = 0;
|
|
const flush = () => {
|
|
while (flushed < files.length && results[flushed] !== undefined) {
|
|
const result = results[flushed];
|
|
if (result && result !== 'failed') {
|
|
setLocalImages((current) => ({ ...current, [result.id]: result }));
|
|
slides.append({ id: null, imageId: result.id, alt: '', decorative: false, isActive: true }, { shouldFocus: false });
|
|
}
|
|
flushed += 1;
|
|
}
|
|
};
|
|
|
|
const worker = async () => {
|
|
while (cursor < files.length) {
|
|
const i = cursor++;
|
|
const file = files[i];
|
|
// Refuse what the host would refuse without sending the whole file first.
|
|
if (file.type !== '' && !file.type.startsWith('image/')) {
|
|
results[i] = 'failed';
|
|
update(i, { status: 'failed', message: t('hero.upload.notAnImage') });
|
|
} else if (file.size > maxBytes) {
|
|
results[i] = 'failed';
|
|
update(i, { status: 'failed', message: t('hero.upload.tooLarge', { max: maxMb }) });
|
|
} else {
|
|
update(i, { status: 'uploading' });
|
|
try {
|
|
const image = await upload.mutateAsync(file);
|
|
results[i] = image;
|
|
update(i, { status: 'done' });
|
|
} catch (error) {
|
|
results[i] = 'failed';
|
|
update(i, { status: 'failed', message: uploadMessage(error, t) });
|
|
}
|
|
}
|
|
flush();
|
|
}
|
|
};
|
|
|
|
try {
|
|
await Promise.all(Array.from({ length: Math.min(UPLOAD_PARALLEL, files.length) }, () => worker()));
|
|
} finally {
|
|
setUploading(false);
|
|
if (fileInput.current) fileInput.current.value = '';
|
|
}
|
|
};
|
|
|
|
const sensors = useSensors(
|
|
useSensor(PointerSensor, { activationConstraint: { distance: 6 } }),
|
|
useSensor(KeyboardSensor, { coordinateGetter: sortableKeyboardCoordinates }),
|
|
);
|
|
|
|
// The order changes in the form only; it goes live when the hero is saved, like every other change.
|
|
const onDragEnd = (event: DragEndEvent) => {
|
|
const { active, over } = event;
|
|
if (!over || active.id === over.id) return;
|
|
const from = slides.fields.findIndex((f) => f.id === active.id);
|
|
const to = slides.fields.findIndex((f) => f.id === over.id);
|
|
if (from !== -1 && to !== -1) slides.move(from, to);
|
|
};
|
|
|
|
const isFileDrag = (event: React.DragEvent) => Array.from(event.dataTransfer?.types ?? []).includes('Files');
|
|
|
|
const onSubmit = async (values: HeroFormData) => {
|
|
setServerError(null);
|
|
try {
|
|
const savedHero = await save.mutateAsync(toRequest(values, focusEdits));
|
|
setFocusEdits({});
|
|
// What was just saved is the new starting point: nothing is unsaved any more.
|
|
reset(toForm(savedHero));
|
|
toast.success(t('hero.savedToast'));
|
|
} catch (error) {
|
|
setServerError(serverMessage(error, t('errors.generic'), t('errors.network')));
|
|
}
|
|
};
|
|
|
|
const err = (message?: string) => (message ? t(message) : undefined);
|
|
const heroErrors = errors;
|
|
|
|
return (
|
|
<form onSubmit={handleSubmit(onSubmit)} className="space-y-8" noValidate data-testid="hero-form">
|
|
<FormErrorBanner error={serverError !== null ? { message: serverError } : null} onDismiss={() => setServerError(null)} />
|
|
|
|
<section className="space-y-4">
|
|
<div className="space-y-2">
|
|
<Label htmlFor="hero-title-input">{t('hero.fields.title')}</Label>
|
|
<textarea id="hero-title-input" rows={3} className={textareaClass} data-testid="hero-title-input" {...register('title')} />
|
|
<p className="text-xs text-muted-foreground">{t('hero.fields.titleHint')}</p>
|
|
<FieldError message={err(heroErrors.title?.message)} testId="hero-title-error" />
|
|
</div>
|
|
<div className="space-y-2">
|
|
<Label htmlFor="hero-tagline">{t('hero.fields.tagline')}</Label>
|
|
<Input id="hero-tagline" maxLength={120} data-testid="hero-tagline" {...register('tagline')} />
|
|
<FieldError message={err(heroErrors.tagline?.message)} />
|
|
</div>
|
|
<div className="space-y-2">
|
|
<Label htmlFor="hero-lead">{t('hero.fields.lead')}</Label>
|
|
<textarea id="hero-lead" rows={3} className={textareaClass} data-testid="hero-lead" {...register('lead')} />
|
|
<FieldError message={err(heroErrors.lead?.message)} />
|
|
</div>
|
|
<fieldset className="space-y-2">
|
|
<legend className="text-sm font-medium">{t('hero.fields.display')}</legend>
|
|
<div className="flex flex-wrap gap-4 text-sm">
|
|
{(['single', 'slideshow'] as const).map((value) => (
|
|
<label key={value} className="flex items-center gap-2">
|
|
<input type="radio" value={value} data-testid={`hero-display-${value}`} {...register('display')} />
|
|
{t(`hero.display.${value}`)}
|
|
</label>
|
|
))}
|
|
</div>
|
|
</fieldset>
|
|
</section>
|
|
|
|
<section className="space-y-3">
|
|
<h2 className="text-lg font-medium">{t('hero.buttons.title')}</h2>
|
|
<p className="text-xs text-muted-foreground">{t('hero.buttons.hint')}</p>
|
|
{[0, 1].map((i) => (
|
|
<div key={i} className="grid gap-3 sm:grid-cols-2">
|
|
<div className="space-y-1">
|
|
<Label htmlFor={`hero-button-${i}-label`}>{t('hero.buttons.label', { n: i + 1 })}</Label>
|
|
<Input id={`hero-button-${i}-label`} maxLength={50} data-testid={`hero-button-${i}-label`} {...register(`buttons.${i}.label` as const)} />
|
|
<FieldError message={err(heroErrors.buttons?.[i]?.label?.message)} testId={`hero-button-${i}-label-error`} />
|
|
</div>
|
|
<div className="space-y-1">
|
|
<Label htmlFor={`hero-button-${i}-target`}>{t('hero.buttons.target', { n: i + 1 })}</Label>
|
|
<Input id={`hero-button-${i}-target`} maxLength={500} placeholder="#contact, /over-mij, https://…" data-testid={`hero-button-${i}-target`} {...register(`buttons.${i}.target` as const)} />
|
|
<FieldError message={err(heroErrors.buttons?.[i]?.target?.message)} testId={`hero-button-${i}-target-error`} />
|
|
</div>
|
|
</div>
|
|
))}
|
|
</section>
|
|
|
|
<section className="space-y-3">
|
|
<h2 className="text-lg font-medium">{t('hero.schedule.title')}</h2>
|
|
<label className="flex items-center gap-2 text-sm">
|
|
<input type="checkbox" className="size-4 rounded border-input" data-testid="hero-active" {...register('isActive')} />
|
|
{t('hero.schedule.active')}
|
|
</label>
|
|
<div className="grid gap-3 sm:grid-cols-2">
|
|
<div className="space-y-1">
|
|
<Label htmlFor="hero-starts">{t('hero.schedule.starts')}</Label>
|
|
<Input id="hero-starts" type="datetime-local" data-testid="hero-starts" {...register('startsAt')} />
|
|
</div>
|
|
<div className="space-y-1">
|
|
<Label htmlFor="hero-ends">{t('hero.schedule.ends')}</Label>
|
|
<Input id="hero-ends" type="datetime-local" data-testid="hero-ends" {...register('endsAt')} />
|
|
<FieldError message={err(heroErrors.endsAt?.message)} testId="hero-ends-error" />
|
|
</div>
|
|
</div>
|
|
<p className="text-xs text-muted-foreground">{t('hero.schedule.hint')}</p>
|
|
</section>
|
|
|
|
<section
|
|
className={`space-y-3 rounded-md ${draggingFiles ? 'ring-2 ring-primary ring-offset-4' : ''}`}
|
|
onDragOver={(event) => {
|
|
if (!isFileDrag(event)) return;
|
|
event.preventDefault();
|
|
setDraggingFiles(true);
|
|
}}
|
|
onDragLeave={(event) => {
|
|
if (!event.currentTarget.contains(event.relatedTarget as Node | null)) setDraggingFiles(false);
|
|
}}
|
|
onDrop={(event) => {
|
|
if (!isFileDrag(event)) return;
|
|
event.preventDefault();
|
|
setDraggingFiles(false);
|
|
void onFiles(event.dataTransfer.files);
|
|
}}
|
|
data-testid="hero-slides-section"
|
|
>
|
|
<div className="flex flex-wrap items-center justify-between gap-2">
|
|
<h2 className="text-lg font-medium">{t('hero.slides.title')}</h2>
|
|
<div>
|
|
<input
|
|
ref={fileInput}
|
|
id="hero-upload"
|
|
type="file"
|
|
accept="image/*"
|
|
multiple
|
|
className="sr-only"
|
|
aria-label={t('hero.slides.add')}
|
|
data-testid="hero-upload"
|
|
onChange={(event) => void onFiles(event.target.files)}
|
|
/>
|
|
<Button type="button" variant="outline" disabled={uploading} onClick={() => fileInput.current?.click()} data-testid="hero-upload-button">
|
|
<ImagePlus className="mr-2 size-4" aria-hidden="true" />
|
|
{uploading ? t('hero.slides.uploading') : t('hero.slides.add')}
|
|
</Button>
|
|
</div>
|
|
</div>
|
|
<p className="text-xs text-muted-foreground">{t('hero.slides.hint')}</p>
|
|
{limits && (
|
|
<p className="text-xs text-muted-foreground" data-testid="hero-upload-limits">
|
|
{t('hero.slides.limits', { formats: limits.formats.join(', '), size: Math.round(limits.maxUploadBytes / (1024 * 1024)), megapixels: limits.maxMegapixels })}
|
|
</p>
|
|
)}
|
|
<UploadProgress items={uploads} busy={uploading} onClose={() => setUploads([])} />
|
|
{slides.fields.length === 0 && <p className="text-sm text-muted-foreground" data-testid="hero-slides-empty">{t('hero.slides.empty')}</p>}
|
|
|
|
<DndContext
|
|
sensors={sensors}
|
|
collisionDetection={closestCenter}
|
|
onDragEnd={onDragEnd}
|
|
accessibility={{ screenReaderInstructions: { draggable: t('hero.slides.dragInstructions') } }}
|
|
>
|
|
<SortableContext items={slides.fields.map((f) => f.id)} strategy={verticalListSortingStrategy}>
|
|
<ol className="space-y-3" data-testid="hero-slides">
|
|
{slides.fields.map((field, index) => {
|
|
const image = images[field.imageId];
|
|
const decorative = watchedSlides[index]?.decorative ?? false;
|
|
return (
|
|
<SortableSlide key={field.id} id={field.id} index={index}>
|
|
{image && image.variants.length === 0 ? (
|
|
<PhotoPlaceholder failed={image.failed} testId={`hero-slide-${index}-processing`} />
|
|
) : image ? (
|
|
<img src={thumbnail(image)} alt="" className="h-20 w-28 rounded object-cover" />
|
|
) : (
|
|
<div className="flex h-20 w-28 items-center justify-center rounded bg-muted text-xs">?</div>
|
|
)}
|
|
<div className="min-w-[12rem] flex-1 space-y-2">
|
|
<Label htmlFor={`hero-slide-${index}-alt`}>{t('hero.slides.alt', { n: index + 1 })}</Label>
|
|
<Input id={`hero-slide-${index}-alt`} maxLength={300} disabled={decorative} aria-describedby={`hero-slide-${index}-alt-hint`} data-testid={`hero-slide-${index}-alt`} {...register(`slides.${index}.alt` as const)} />
|
|
<p id={`hero-slide-${index}-alt-hint`} className="text-xs text-muted-foreground">{t('hero.slides.altHint')}</p>
|
|
<FieldError message={err(heroErrors.slides?.[index]?.alt?.message)} testId={`hero-slide-${index}-alt-error`} />
|
|
{focusEdits[field.imageId] && (
|
|
<p className="text-xs font-medium" data-testid={`hero-slide-${index}-focus-pending`}>{t('hero.slides.focusPending')}</p>
|
|
)}
|
|
<div className="flex flex-wrap gap-4 text-sm">
|
|
<label className="flex items-center gap-2">
|
|
<input type="checkbox" className="size-4 rounded border-input" data-testid={`hero-slide-${index}-decorative`} {...register(`slides.${index}.decorative` as const)} />
|
|
<span>
|
|
{t('hero.slides.decorative')}
|
|
<span className="block text-xs text-muted-foreground">{t('hero.slides.decorativeHint')}</span>
|
|
</span>
|
|
</label>
|
|
<label className="flex items-center gap-2">
|
|
<input type="checkbox" className="size-4 rounded border-input" data-testid={`hero-slide-${index}-active`} {...register(`slides.${index}.isActive` as const)} />
|
|
{t('hero.slides.active')}
|
|
</label>
|
|
</div>
|
|
</div>
|
|
<div className="flex gap-1">
|
|
<Button type="button" variant="outline" size="icon" aria-label={t('hero.slides.up')} disabled={index === 0} onClick={() => slides.move(index, index - 1)} data-testid={`hero-slide-${index}-up`}>
|
|
<ArrowUp className="size-4" aria-hidden="true" />
|
|
</Button>
|
|
<Button type="button" variant="outline" size="icon" aria-label={t('hero.slides.down')} disabled={index === slides.fields.length - 1} onClick={() => slides.move(index, index + 1)} data-testid={`hero-slide-${index}-down`}>
|
|
<ArrowDown className="size-4" aria-hidden="true" />
|
|
</Button>
|
|
<Button type="button" variant={focusEdits[field.imageId] ? 'default' : 'outline'} size="icon" aria-label={t('hero.slides.focus')} disabled={!image || image.variants.length === 0} onClick={() => setFocusImageId(field.imageId)} data-testid={`hero-slide-${index}-focus`}>
|
|
<Crosshair className="size-4" aria-hidden="true" />
|
|
</Button>
|
|
<Button type="button" variant="outline" size="icon" aria-label={t('hero.slides.remove')} onClick={() => slides.remove(index)} data-testid={`hero-slide-${index}-remove`}>
|
|
<Trash2 className="size-4" aria-hidden="true" />
|
|
</Button>
|
|
</div>
|
|
</SortableSlide>
|
|
);
|
|
})}
|
|
</ol>
|
|
</SortableContext>
|
|
</DndContext>
|
|
{slides.fields.length > hero.maxPublishedSlides && (
|
|
<p className="text-xs text-muted-foreground" data-testid="hero-ceiling-note">
|
|
{t('hero.slides.ceiling', { max: hero.maxPublishedSlides })}
|
|
</p>
|
|
)}
|
|
</section>
|
|
|
|
<UnsavedChangesGuard dirty={hasUnsaved} />
|
|
<div className="sticky bottom-0 z-20 -mx-1 flex flex-wrap items-center justify-end gap-3 border-t bg-background/95 px-1 py-3 backdrop-blur">
|
|
<div role="status" aria-live="polite" className="min-h-5 flex-1 text-sm" data-testid="hero-unsaved-region">
|
|
{hasUnsaved && (
|
|
<span className="inline-flex items-center gap-2" data-testid="hero-unsaved">
|
|
<Badge variant="secondary">{t('hero.unsaved.badge')}</Badge>
|
|
<span className="text-muted-foreground">{t('hero.unsaved.text')}</span>
|
|
</span>
|
|
)}
|
|
</div>
|
|
<Button type="submit" disabled={save.isPending} className={hasUnsaved ? 'ring-2 ring-primary ring-offset-2' : undefined} data-testid="hero-save">
|
|
{save.isPending ? '…' : t('common.save')}
|
|
</Button>
|
|
</div>
|
|
|
|
<FocusDialog
|
|
image={withPendingFocus(focusImageId ? images[focusImageId] ?? null : null)}
|
|
onApply={(imageId, edit) => setFocusEdits((current) => ({ ...current, [imageId]: edit }))}
|
|
onClose={() => setFocusImageId(null)}
|
|
/>
|
|
</form>
|
|
);
|
|
}
|