@cardinali-studio/adminkit 1.0.0

package/dist/app/lib/settings.js

@@ -0,0 +1,82 @@
+/* Stato delle impostazioni globali.
+ *
+ * È un singleton come la home, ma usa JSON perché lo leggono sia Hugo sia il middleware che
+ * protegge il sito. La password digitata resta soltanto nello stato del form: il backend
+ * restituisce sempre il campo vuoto e conserva esclusivamente la verifica crittografica.
+ */
+import { useCallback, useEffect, useState } from "react";
+import { ApiError } from "../../index.js";
+const empty = {
+    siteTitle: "",
+    shortDescription: "",
+    favicon: "",
+    ownerName: "",
+    siteDescription: "",
+    seoWebsiteTitle: "",
+    searchEngineIndexing: true,
+    blockAiTraining: false,
+    analyticsTag: "",
+    features: { analytics: false, appointments: false },
+    passwordEnabled: false,
+    password: "",
+};
+async function call(url, init) {
+    const res = await fetch(url, { cache: "no-store", ...init });
+    const body = await res.json().catch(() => null);
+    if (!res.ok || body?.ok === false) {
+        throw new ApiError(body?.error ?? `HTTP ${res.status}`, body?.code ?? (res.status === 401 ? "unauthenticated" : "error"), res.status);
+    }
+    return body;
+}
+export function useSiteSettings(active) {
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [dirty, setDirty] = useState(false);
+    const [saving, setSaving] = useState(false);
+    const [notice, setNotice] = useState(null);
+    const load = useCallback(async () => {
+        try {
+            const result = await call("/admin/api/settings");
+            setData({ ...empty, ...result.settings, password: "" });
+            setError(null);
+            setDirty(false);
+        }
+        catch (e) {
+            setError(e.message);
+        }
+    }, []);
+    useEffect(() => {
+        if (active && data === null && error === null)
+            void load();
+    }, [active, data, error, load]);
+    const save = useCallback(async () => {
+        if (!data)
+            return;
+        setSaving(true);
+        setNotice(null);
+        try {
+            const result = await call("/admin/api/settings", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(data),
+            });
+            setData({ ...empty, ...result.settings, password: "" });
+            setDirty(false);
+            setNotice("Pubblicato — build in corso");
+        }
+        catch (e) {
+            const err = e;
+            setNotice(err.code === "unauthenticated"
+                ? "Sessione scaduta: ricarica la pagina per rientrare."
+                : err.message);
+        }
+        finally {
+            setSaving(false);
+        }
+    }, [data]);
+    const change = useCallback((next) => {
+        setData(next);
+        setDirty(true);
+    }, []);
+    return { data, error, dirty, saving, notice, load, change, save, setNotice };
+}

package/dist/app/lib/slug.d.ts

@@ -0,0 +1,3 @@
+export declare function slugify(s: string): string;
+/** Slug libero, aggiungendo -2, -3… finché non collide più. */
+export declare function uniqueSlug(base: string, taken: readonly string[]): string;

package/dist/app/lib/slug.js

@@ -0,0 +1,23 @@
+/* Slug: è il nome della cartella in `content/`, quindi anche l'URL della pagina.
+ * Il server accetta solo `^[a-z0-9-]+$` (pages.js), e qui si produce già quella forma invece
+ * di far arrivare al salvataggio un valore che verrà rifiutato. */
+export function slugify(s) {
+    return String(s)
+        .normalize("NFKD").replace(/[\u0300-\u036f]/g, "") // via gli accenti
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 60) || "pagina";
+}
+/** Slug libero, aggiungendo -2, -3… finché non collide più. */
+export function uniqueSlug(base, taken) {
+    const b = slugify(base);
+    if (!taken.includes(b))
+        return b;
+    for (let i = 2; i < 500; i++) {
+        const s = `${b}-${i}`;
+        if (!taken.includes(s))
+            return s;
+    }
+    return `${b}-${Date.now().toString(36)}`;
+}

package/dist/app/lib/text.d.ts

@@ -0,0 +1 @@
+export declare function proseStats(text: string): string;

package/dist/app/lib/text.js

@@ -0,0 +1,13 @@
+/* Quanto testo c'è, detto come lo direbbe una persona.
+ *
+ * Non è una statistica: è il modo di accorgersi di aver cancellato un paragrafo senza rileggere
+ * tutto. Sta qui perché la usano la biografia della pagina "chi sono" e l'introduzione dei
+ * workshop — gli unici due posti in cui il corpo markdown è il contenuto principale.
+ */
+export function proseStats(text) {
+    const paragraphs = text.split(/\n\s*\n/).filter((piece) => piece.trim()).length;
+    const words = text.trim() ? text.trim().split(/\s+/).length : 0;
+    if (!words)
+        return "Vuoto";
+    return `${paragraphs} ${paragraphs === 1 ? "paragrafo" : "paragrafi"} · ${words} parole`;
+}

package/dist/app/lib/theme.d.ts

@@ -0,0 +1,7 @@
+export type Theme = "light" | "dark";
+export declare function initialTheme(): Theme;
+export declare function applyTheme(theme: Theme): void;
+export declare function useTheme(): {
+    theme: Theme;
+    toggle: () => void;
+};

package/dist/app/lib/theme.js

@@ -0,0 +1,43 @@
+/* Il tema chiaro/scuro del pannello: dove vive, come si applica, come si ricorda.
+ *
+ * L'attributo si scrive su `document.documentElement`, non su `.app`: `body` (in app.css) ha
+ * `background: var(--ak-bg)` ed è un ANTENATO di `.app`, non un discendente — se l'attributo
+ * stesse su `.app`, il fondo di `body` resterebbe quello chiaro e si vedrebbe un lampo chiaro
+ * nell'overscroll di Safari. Sulla radice lo eredita tutto, `body` compreso.
+ */
+import { useEffect, useState } from "react";
+import { storageKey } from "../../index.js";
+const KEY = storageKey("theme"); // col prefisso del sito davanti, es. «<prefisso>_theme»
+function systemPrefersDark() {
+    return typeof matchMedia !== "undefined" && matchMedia("(prefers-color-scheme: dark)").matches;
+}
+/* Pura e idempotente: la richiama sia il bootstrap sincrono in main.tsx (per evitare il lampo
+   del tema sbagliato al primo render), sia questo modulo, per inizializzare lo stato React allo
+   stesso valore già scritto sul DOM. */
+export function initialTheme() {
+    try {
+        const saved = localStorage.getItem(KEY);
+        if (saved === "light" || saved === "dark")
+            return saved;
+    }
+    catch {
+        /* localStorage non disponibile: si ripiega sulla preferenza di sistema. */
+    }
+    return systemPrefersDark() ? "dark" : "light";
+}
+export function applyTheme(theme) {
+    document.documentElement.setAttribute("data-theme", theme);
+}
+export function useTheme() {
+    const [theme, setTheme] = useState(initialTheme);
+    useEffect(() => {
+        applyTheme(theme);
+        try {
+            localStorage.setItem(KEY, theme);
+        }
+        catch {
+            /* Niente da fare: la scelta vale solo per questa sessione. */
+        }
+    }, [theme]);
+    return { theme, toggle: () => setTheme((t) => (t === "light" ? "dark" : "light")) };
+}

package/dist/app/lib/upload-queue.d.ts

@@ -0,0 +1,35 @@
+import { type DeliveryUploadProgress } from "./delivery-upload";
+export type UploadState = "running" | "paused" | "done" | "failed";
+export interface UploadJob {
+    /** L'id del pacchetto: uno per caricamento. */
+    id: string;
+    deliveryId: string;
+    title: string;
+    totalFiles: number;
+    sourceBytes: number;
+    state: UploadState;
+    progress: DeliveryUploadProgress | null;
+    error?: string;
+    skipped?: number;
+}
+interface StartInput {
+    deliveryId: string;
+    packageId: string;
+    title: string;
+    files: File[];
+    options: {
+        galleryEnabled: boolean;
+        webEnabled: boolean;
+    };
+}
+export declare function useUploads(): UploadJob[];
+export declare function useUploadCompletions(): number;
+export declare function uploadFor(deliveryId: string, list: UploadJob[]): UploadJob | undefined;
+export declare function isBusy(job: UploadJob | undefined): boolean;
+export declare function startUpload(input: StartInput): void;
+export declare function pauseUpload(id: string): void;
+export declare function resumeUpload(id: string): void;
+export declare function cancelUpload(id: string): void;
+export declare function dismissUpload(id: string): void;
+export declare function hasRunningUploads(): boolean;
+export {};

package/dist/app/lib/upload-queue.js

@@ -0,0 +1,167 @@
+/* La coda dei caricamenti — fuori da React, di proposito.
+ *
+ * Prima lo stato dell'upload viveva DENTRO la schermata del transfer: uscire da lì lo
+ * uccideva, e per questo il pannello si disabilitava da solo mentre caricava. Su quaranta
+ * giga significa ore di pannello inutilizzabile per qualsiasi altra cosa.
+ *
+ * Qui lo stato sta a livello di modulo — non in un contesto, non in un componente — quindi
+ * non c'è niente che possa smontarlo. I componenti si limitano a guardarlo con
+ * `useSyncExternalStore`. È anche il motivo per cui questo file non ha JSX: la coda non è
+ * un pezzo di interfaccia, l'interfaccia è `routes/UploadDock.tsx`.
+ *
+ * Chi lo usa:
+ *   Deliveries.tsx  avvia (`startUpload`) e mostra l'avanzamento del proprio transfer
+ *   UploadDock.tsx  mostra tutti i caricamenti, e li mette in pausa o li annulla
+ *   App.tsx         ricarica l'elenco quando uno finisce (`useUploadCompletions`)
+ */
+import { useSyncExternalStore } from "react";
+import { UploadCancelled, uploadDeliveryPackage, } from "./delivery-upload";
+import { deliveryAction } from "./deliveries";
+/* ---- lo stato ------------------------------------------------------------------------ */
+let jobs = [];
+let completions = 0;
+const gates = new Map();
+const listeners = new Set();
+function emit() {
+    jobs = [...jobs];
+    for (const listener of listeners)
+        listener();
+}
+function patch(id, change) {
+    jobs = jobs.map((job) => (job.id === id ? { ...job, ...change } : job));
+    for (const listener of listeners)
+        listener();
+}
+function subscribe(listener) {
+    listeners.add(listener);
+    return () => { listeners.delete(listener); };
+}
+/* `jobs` cambia identità solo dentro emit/patch: `useSyncExternalStore` può confrontarla. */
+export function useUploads() {
+    return useSyncExternalStore(subscribe, () => jobs, () => jobs);
+}
+/* Un numero che cresce quando un caricamento FINISCE, comunque sia andato. Chi deve solo
+   rileggere i dati si abbona a questo e non all'avanzamento, altrimenti si ridisegnerebbe
+   due volte al secondo per tutta la durata dell'upload. */
+export function useUploadCompletions() {
+    return useSyncExternalStore(subscribe, () => completions, () => completions);
+}
+export function uploadFor(deliveryId, list) {
+    return list.find((job) => job.deliveryId === deliveryId);
+}
+export function isBusy(job) {
+    return !!job && (job.state === "running" || job.state === "paused");
+}
+/* ---- il cancello --------------------------------------------------------------------- */
+/* Pausa e annullamento passano da qui: il motore (delivery-upload.ts) chiama `gate()` a ogni
+   file e a ogni parte, e questa promessa lo tiene fermo finché non si riprende. */
+class Gate {
+    paused = false;
+    cancelled = false;
+    waiting = [];
+    async gate() {
+        if (this.cancelled)
+            throw new UploadCancelled();
+        while (this.paused) {
+            await new Promise((resolve) => this.waiting.push(resolve));
+            if (this.cancelled)
+                throw new UploadCancelled();
+        }
+    }
+    wake() {
+        const waiting = this.waiting;
+        this.waiting = [];
+        for (const resolve of waiting)
+            resolve();
+    }
+}
+/* ---- i comandi ------------------------------------------------------------------------ */
+export function startUpload(input) {
+    const gate = new Gate();
+    gates.set(input.packageId, gate);
+    jobs = [...jobs.filter((job) => job.id !== input.packageId), {
+            id: input.packageId,
+            deliveryId: input.deliveryId,
+            title: input.title,
+            totalFiles: input.files.length,
+            sourceBytes: input.files.reduce((sum, file) => sum + file.size, 0),
+            state: "running",
+            progress: null,
+        }];
+    emit();
+    void run(input, gate);
+}
+async function run(input, gate) {
+    const id = input.packageId;
+    try {
+        const result = await uploadDeliveryPackage(input.deliveryId, id, input.files, input.options, (progress) => patch(id, { progress }), gate);
+        /* Chiusura e attivazione stanno QUI e non nella schermata: se finiscono mentre il
+           fotografo sta guardando un'altra sezione, devono succedere lo stesso. */
+        await deliveryAction({
+            action: "finalizePackage", id: input.deliveryId, packageId: id,
+            manifest: result.manifest, fileCount: result.fileCount,
+            sourceBytes: result.sourceBytes, storedBytes: result.storedBytes,
+        });
+        await deliveryAction({ action: "activate", id: input.deliveryId }).catch(() => { });
+        patch(id, { state: "done", progress: null, skipped: result.manifest.skipped.length });
+    }
+    catch (error) {
+        if (error instanceof UploadCancelled) {
+            /* Annullare vuol dire «come se non l'avessi mai iniziato»: il pacchetto sparisce, e
+               con lui il multipart aperto su B2. */
+            await deliveryAction({
+                action: "deletePackage", id: input.deliveryId, packageId: id,
+            }).catch(() => { });
+            jobs = jobs.filter((job) => job.id !== id);
+        }
+        else {
+            patch(id, { state: "failed", progress: null, error: readable(error) });
+        }
+    }
+    finally {
+        gates.delete(id);
+        completions += 1;
+        emit();
+    }
+}
+export function pauseUpload(id) {
+    const gate = gates.get(id);
+    if (!gate)
+        return;
+    gate.paused = true;
+    patch(id, { state: "paused" });
+}
+export function resumeUpload(id) {
+    const gate = gates.get(id);
+    if (!gate)
+        return;
+    gate.paused = false;
+    gate.wake();
+    patch(id, { state: "running" });
+}
+export function cancelUpload(id) {
+    const gate = gates.get(id);
+    if (!gate)
+        return;
+    gate.cancelled = true;
+    gate.paused = false;
+    gate.wake();
+}
+/* Toglie dalla vista un caricamento già finito. Su uno in corso non fa niente: per quello
+   c'è `cancelUpload`, che è un'altra cosa e va detta con un'altra parola. */
+export function dismissUpload(id) {
+    jobs = jobs.filter((job) => job.id === id ? isBusy(job) : true);
+    emit();
+}
+export function hasRunningUploads() {
+    return jobs.some((job) => job.state === "running");
+}
+function readable(error) {
+    const raw = error instanceof Error ? error.message : String(error);
+    if ((error instanceof DOMException && error.name === "NotReadableError") ||
+        raw.includes("requested file could not be read")) {
+        return "Il browser non riesce più a leggere uno dei file scelti. " +
+            "Riseleziona la stessa cartella e premi «Riprendi».";
+    }
+    return raw;
+}

package/dist/app/routes/AboutEditor.d.ts

@@ -0,0 +1,15 @@
+import type { AssetFile } from "../../index.js";
+import { normalizeCredits, type Credit } from "../../normalize.js";
+export { normalizeCredits };
+import type { PageModel } from "../lib/pages";
+export type { Credit };
+type Picker = (o: {
+    multiple: boolean;
+}) => Promise<AssetFile[] | null>;
+export declare function AboutEditor({ page, onChange, bodyState, pickMediaFiles }: {
+    page: PageModel;
+    onChange: (next: PageModel) => void;
+    /** Il corpo markdown si rilegge dal repo all'apertura: qui si dice solo a che punto è. */
+    bodyState: "idle" | "loading" | "error";
+    pickMediaFiles?: Picker;
+}): import("react").JSX.Element;

package/dist/app/routes/AboutEditor.js

@@ -0,0 +1,122 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/* La pagina "chi sono".
+ *
+ * ── L'idea ─────────────────────────────────────────────────────────────────────────────────
+ * Come per gallery e portfolio: l'editor mostra LA PAGINA, non i campi della pagina. Questa ha
+ * un'anatomia fissa e riconoscibile — biografia a sinistra, ritratto fermo a destra,
+ * riconoscimenti in coda (ABOUT.md) — e la schermata la rispecchia, ritratto `sticky` compreso.
+ *
+ * Prima cadeva nel ramo generico di `PageEditor`, cioè `SchemaForm` su tutto lo schema `Page`:
+ * comparivano «Lavori», «Edizioni» e «Sezioni» — campi di portfolio, workshop e gallery, che il
+ * form disegna perché lo schema li dichiara e lui non sa che tipo di pagina sta modificando — e
+ * la biografia, che è il contenuto principale, finiva ultima in una textarea grigia.
+ *
+ * NON è modulare come le gallery, e non è una dimenticanza: là l'ordine e la composizione dei
+ * blocchi SONO il contenuto, qui la struttura è una sola e la disegna `about.html`. Un «aggiungi
+ * sezione» prometterebbe una libertà che il template non sa onorare.
+ *
+ * ── La biografia resta markdown ────────────────────────────────────────────────────────────
+ * Il corpo è una stringa e tale rimane: `ParagraphEditor` lavora su `string[]`, e spezzare il
+ * corpo in paragrafi per poi ricomporlo con `\n\n` riscriverebbe il testo di chi usa elenchi,
+ * titoli o righe di codice — cose che nel corpo markdown sono legittime (nel front matter no,
+ * ed è per quello che là i paragrafi sono un array). Cambia solo come lo si guarda: colonna a
+ * misura di lettura, altezza che segue il testo, e il conteggio sotto.
+ *
+ * ── I riconoscimenti ───────────────────────────────────────────────────────────────────────
+ * Tre campi in riga, nella grafia con cui escono sul sito: il ruolo è testo corrente, il nome è
+ * l'entità in evidenza (maiuscoletto, colore d'accento — vedi `.ab-credit-name` in about.css) e
+ * l'indirizzo è il campo quieto sotto. L'indirizzo si vede SEMPRE invece di aprirsi a richiesta:
+ * "aperto/chiuso" sarebbe uno stato per riga da ricalcolare a ogni riordino ed eliminazione —
+ * il prezzo già pagato in `PortfolioWorksEditor` con `openAt` — per nascondere un campo che è
+ * alto una riga.
+ *
+ * Le chiavi del drag & drop sono POSIZIONALI (`credito-2`), come per i lavori: i riconoscimenti
+ * non hanno un `id` nel front matter e non glielo si aggiunge solo per far funzionare
+ * l'interfaccia. Qui non costa niente, perché non c'è nessuno stato "quale riga è aperta".
+ *
+ * ── I recapiti ─────────────────────────────────────────────────────────────────────────────
+ * Non sono campi di questa pagina (stanno nel blocco `contact` della home, vedi ABOUT.md) — ma
+ * nell'admin un'assenza si legge come una dimenticanza. Quindi si dicono: in sola lettura, con
+ * il link a dove si cambiano e l'avviso che cambiarli cambia anche la home. È lo stesso recapito.
+ */
+import { useEffect, useState } from "react";
+import { DndContext, closestCenter } from "@dnd-kit/core";
+import { SortableContext, arrayMove, useSortable, verticalListSortingStrategy, } from "@dnd-kit/sortable";
+import { CSS } from "@dnd-kit/utilities";
+import { ProseField } from "../../form/index.js";
+import { normalizeCredits } from "../../normalize.js";
+export { normalizeCredits };
+import { groupSlug } from "../lib/groups";
+import { proseStats } from "../lib/text";
+import { MediaSlot } from "../ui/MediaSlot";
+import { useDragSensors } from "../ui/dnd";
+import { Icon } from "../ui/icons";
+const str = (value) => (typeof value === "string" ? value : "");
+const list = (value) => (Array.isArray(value) ? value : []);
+/* ---- La biografia -------------------------------------------------------------------------- */
+/* Il campo cresce col testo da sé — è un contenteditable, non una textarea — e questo toglie il
+   caso in cui una biografia di tre paragrafi scorre dentro una finestrella mentre la pagina
+   intorno ha spazio libero. La barra di formattazione arriva con `ProseField`, come ovunque. */
+function ProseEditor({ value, onChange }) {
+    return (_jsx(ProseField, { className: "pw-field ed-prose", value: value, placeholder: "Racconta chi sei.\nVai a capo per iniziare un paragrafo nuovo.", onChange: onChange }));
+}
+/* ---- Un riconoscimento ---------------------------------------------------------------------- */
+function SortableCredit({ id, credit, index, total, onPatch, onRemove }) {
+    const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({ id });
+    const linked = !!credit.href.trim();
+    return (_jsxs("li", { ref: setNodeRef, className: "abo-credit" + (isDragging ? " is-dragging" : ""), style: { transform: CSS.Transform.toString(transform), transition }, children: [_jsxs("div", { className: "abo-credit-main", children: [_jsx("button", { type: "button", className: "pw-grip", "aria-label": `Riordina ${credit.name || "riconoscimento senza nome"}, posizione ${index + 1} di ${total}`, ...attributes, ...listeners, children: _jsx(Icon.grip, {}) }), _jsx("input", { className: "pw-field abo-role", value: credit.label, maxLength: 60, placeholder: "Member of", "aria-label": "Ruolo", onChange: (event) => onPatch({ label: event.target.value }) }), _jsx("input", { className: "pw-field abo-name", value: credit.name, maxLength: 120, placeholder: "Peli Pro Team", "aria-label": "Nome", onChange: (event) => onPatch({ name: event.target.value }) }), _jsx("button", { type: "button", className: "pw-icon-btn is-danger", "aria-label": "Elimina riconoscimento", onClick: onRemove, children: _jsx(Icon.trash, {}) })] }), _jsxs("div", { className: "abo-credit-link" + (linked ? " is-linked" : ""), children: [_jsx("span", { className: "abo-link-mark", "aria-hidden": "true", children: _jsx(Icon.out, {}) }), _jsx("input", { className: "pw-field abo-href", value: credit.href, maxLength: 300, placeholder: "https://\u2026 \u2014 facoltativo: senza, il nome resta testo", "aria-label": "Indirizzo", onChange: (event) => onPatch({ href: event.target.value }) })] })] }));
+}
+function CreditsEditor({ items, onChange }) {
+    const sensors = useDragSensors();
+    const ids = items.map((_, index) => `credito-${index}`);
+    const finish = ({ active, over }) => {
+        if (!over || active.id === over.id)
+            return;
+        const from = ids.indexOf(String(active.id));
+        const to = ids.indexOf(String(over.id));
+        if (from >= 0 && to >= 0)
+            onChange(arrayMove(items, from, to));
+    };
+    return (_jsxs("section", { className: "abo-block", "aria-label": "Riconoscimenti e collaborazioni", children: [_jsxs("header", { className: "pw-head", children: [_jsxs("div", { children: [_jsx("h3", { children: "Riconoscimenti" }), _jsx("p", { children: "Ruolo e nome, nell\u2019ordine in cui si leggono sotto la biografia." })] }), _jsxs("button", { type: "button", className: "btn-soft is-primary", onClick: () => onChange([...items, { label: "", name: "", href: "" }]), children: [_jsx(Icon.plus, {}), " Aggiungi voce"] })] }), items.length === 0 ? (_jsxs("p", { className: "pw-empty-note", children: ["\u00ABMember of ", _jsx("strong", { children: "Peli Pro Team" }), "\u00BB, \u00ABContributor for ", _jsx("strong", { children: "Food & Wine Italy" }), "\u00BB\u2026 Compaiono in coda alla biografia."] })) : (_jsx(DndContext, { sensors: sensors, collisionDetection: closestCenter, onDragEnd: finish, children: _jsx(SortableContext, { items: ids, strategy: verticalListSortingStrategy, children: _jsx("ul", { className: "abo-credits", children: items.map((credit, index) => (_jsx(SortableCredit, { id: ids[index], credit: credit, index: index, total: items.length, onPatch: (patch) => onChange(items.map((item, i) => (i === index ? { ...item, ...patch } : item))), onRemove: () => onChange(items.filter((_, i) => i !== index)) }, ids[index]))) }) }) }))] }));
+}
+/* Sola lettura, e tollerante: se la chiamata non riesce — in anteprima locale senza
+   GITHUB_TOKEN è un 500 — il riquadro resta con il suo testo e il suo link, che è la parte che
+   serve davvero. Un errore rosso qui parlerebbe di una cosa che non si stava facendo. */
+function useSiteContact() {
+    const [contact, setContact] = useState(null);
+    useEffect(() => {
+        let alive = true;
+        fetch("/admin/api/singleton?name=home", { cache: "no-store" })
+            .then((res) => (res.ok ? res.json() : null))
+            .then((body) => {
+            const found = body?.data?.contact;
+            if (alive && found && typeof found === "object")
+                setContact(found);
+        })
+            .catch(() => { });
+        return () => { alive = false; };
+    }, []);
+    return contact;
+}
+function ContactsNote() {
+    const contact = useSiteContact();
+    const rows = [
+        ["Email", str(contact?.email)],
+        ["Telefono", str(contact?.phone)],
+        ["Dove", str(contact?.city)],
+        ["Instagram", str(contact?.instagram)],
+    ].filter(([, value]) => value);
+    return (_jsxs("section", { className: "abo-note", children: [_jsxs("div", { className: "abo-note-text", children: [_jsx("h4", { children: "I recapiti non sono campi di questa pagina" }), _jsx("p", { children: "Sono quelli del sito: la pagina li legge dal blocco \u00ABScrivimi\u00BB della home, che alimenta anche la schermata dei contatti. Cambiarli l\u00EC li cambia in tutti e due i posti \u2014 \u00E8 lo stesso recapito." })] }), !!rows.length && (_jsx("dl", { className: "abo-note-list", children: rows.map(([label, value]) => (_jsxs("div", { children: [_jsx("dt", { children: label }), _jsx("dd", { children: value })] }, label))) })), _jsx("a", { className: "btn-soft", href: `#/home/${groupSlug("Contatto")}`, children: "Modifica nella home" })] }));
+}
+/* ---- La schermata ---------------------------------------------------------------------------- */
+export function AboutEditor({ page, onChange, bodyState, pickMediaFiles }) {
+    const bio = str(page.body);
+    const portrait = str(page.portrait);
+    const credits = normalizeCredits(page.credits);
+    const choosePortrait = async () => {
+        const file = (await pickMediaFiles?.({ multiple: false }))?.[0];
+        if (file)
+            onChange({ ...page, portrait: file.url });
+    };
+    return (_jsxs("section", { className: "abo", "aria-label": "Pagina chi sono", children: [_jsxs("div", { className: "abo-main", children: [_jsxs("section", { className: "abo-block", "aria-label": "Biografia", children: [_jsxs("header", { className: "pw-head", children: [_jsxs("div", { children: [_jsx("h3", { children: "Biografia" }), _jsx("p", { children: "Il testo che si legge accanto al ritratto." })] }), _jsx("span", { className: "ed-count", children: bodyState === "loading" ? "Carico…" : proseStats(bio) })] }), bodyState === "error" && (_jsx("p", { className: "ak-error", children: "Non sono riuscito a caricare il testo dal sito. Ricarica prima di modificarlo." })), _jsx(ProseEditor, { value: bio, onChange: (body) => onChange({ ...page, body }) }), _jsx("p", { className: "pw-empty-note", children: "Seleziona una parola per metterla in grassetto, in corsivo o per collegarla." })] }), _jsx(CreditsEditor, { items: credits, onChange: (next) => onChange({ ...page, credits: next }) }), _jsx(ContactsNote, {})] }), _jsx("aside", { className: "abo-side", children: _jsxs("div", { className: "abo-side-inner", children: [_jsx("h3", { children: "Ritratto" }), _jsx(MediaSlot, { value: portrait, ratio: "portrait", empty: "Scegli il ritratto", onPick: () => void choosePortrait(), onClear: () => onChange({ ...page, portrait: "" }) }), _jsx("p", { className: "pw-empty-note", children: "Resta fermo accanto al testo mentre si scorre. Su schermo stretto passa sopra la biografia: incolonnati, \u00E8 la foto ad aprire la pagina." })] }) })] }));
+}

package/dist/app/routes/Bookings.d.ts

@@ -0,0 +1,21 @@
+import type { Booking, useBookings } from "../lib/bookings";
+type Store = ReturnType<typeof useBookings>;
+export declare function BookingsList({ rows, current, onOpen, onAgenda, onSettings, }: {
+    rows: Booking[];
+    current?: string;
+    onOpen: (id: string) => void;
+    onAgenda: () => void;
+    onSettings: () => void;
+}): import("react").JSX.Element;
+export declare function BookingAgenda({ store, onOpen }: {
+    store: Store;
+    onOpen: (id: string) => void;
+}): import("react").JSX.Element;
+export declare function BookingDetail({ row, store }: {
+    row: Booking;
+    store: Store;
+}): import("react").JSX.Element;
+export declare function BookingSettingsHub({ store }: {
+    store: Store;
+}): import("react").JSX.Element;
+export {};