@cardinali-studio/adminkit 1.0.0

package/dist/app/lib/home.js

@@ -0,0 +1,67 @@
+/* Stato dei contenuti della home. Estratto da HomeEditor perché ora serve in due posti: il form
+ * (terza colonna) e il bottone «Salva e pubblica» (barra in alto), che non è più dentro l'editor.
+ *
+ * Resta un SINGLETON, con endpoint e salvataggio suoi: non passa da /admin/api/pages, il cui
+ * contratto è "ecco l'elenco completo, cancella il resto".
+ *
+ * Il caricamento è PIGRO: parte quando si entra nella home, non all'avvio del pannello. Chi apre
+ * l'admin per riordinare le pagine non ha motivo di pagare una chiamata in più — e senza
+ * GITHUB_TOKEN, in anteprima locale, quella chiamata è un 500.
+ */
+import { useCallback, useEffect, useState } from "react";
+import { ApiError } from "../../index.js";
+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 useHome(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 {
+            setData((await call("/admin/api/singleton?name=home")).data);
+            setError(null);
+            setDirty(false);
+        }
+        catch (e) {
+            setError(e.message);
+        }
+    }, []);
+    // Una volta caricata resta in memoria: tornare sulla home dopo un giro nelle pagine non deve
+    // buttare via le modifiche non salvate.
+    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 {
+            await call("/admin/api/singleton", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ name: "home", data }),
+            });
+            setNotice("Pubblicato — build in corso");
+            setDirty(false);
+        }
+        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/overview.d.ts

@@ -0,0 +1,82 @@
+export interface StorageR2 {
+    ok: boolean;
+    error?: string;
+    objects: number;
+    bytes: number;
+    trashObjects: number;
+    trashBytes: number;
+    partial: boolean;
+    cached?: boolean;
+}
+export interface StorageB2 {
+    ok: boolean;
+    error?: string;
+    bytes: number;
+    sourceBytes: number;
+    files: number;
+    packages: number;
+    heroes: number;
+    pendingBytes: number;
+    configured: boolean;
+}
+export interface StorageData {
+    r2: StorageR2;
+    b2: StorageB2;
+}
+export type AnalyticsRange = "24h" | "7d" | "30d";
+export interface AnalyticsMetric {
+    value: number;
+    prev: number | null;
+}
+export interface AnalyticsPoint {
+    date: string;
+    pageviews: number;
+    sessions: number;
+}
+export interface AnalyticsEntry {
+    name: string;
+    count: number;
+}
+export interface AnalyticsSetting {
+    name: string;
+    secret: boolean;
+}
+export interface AnalyticsProviderInfo {
+    id: string;
+    label: string;
+    missing: AnalyticsSetting[];
+}
+export interface AnalyticsData {
+    configured: boolean;
+    providers?: AnalyticsProviderInfo[];
+    provider?: string;
+    providerLabel?: string;
+    range?: AnalyticsRange;
+    unit?: "hour" | "day";
+    startAt?: number;
+    endAt?: number;
+    totals?: {
+        pageviews: AnalyticsMetric;
+        visitors: AnalyticsMetric;
+        visits: AnalyticsMetric;
+        bounces: AnalyticsMetric;
+        totaltime: AnalyticsMetric;
+    };
+    series?: AnalyticsPoint[];
+    pages?: AnalyticsEntry[];
+    referrers?: AnalyticsEntry[];
+}
+export declare function useStorage(active: boolean): {
+    data: StorageData | null;
+    error: string | null;
+    busy: boolean;
+    load: (fresh?: boolean) => Promise<void>;
+};
+export declare function useAnalytics(active: boolean): {
+    data: AnalyticsData | null;
+    error: string | null;
+    busy: boolean;
+    range: AnalyticsRange;
+    setRange: import("react").Dispatch<import("react").SetStateAction<AnalyticsRange>>;
+    reload: () => Promise<void>;
+};

package/dist/app/lib/overview.js

@@ -0,0 +1,68 @@
+/* I due caricamenti della Panoramica.
+ *
+ * Sono due e non uno perché falliscono in modi diversi: lo spazio è roba nostra (R2 e D1) e o
+ * c'è o c'è un guasto; le visite passano da Umami, che può essere non collegato, lento o giù —
+ * e in nessuno di quei casi il resto della schermata deve restare fermo ad aspettarlo.
+ *
+ * Quello che NON sta qui: transfer e richieste. Sono già caricati da `useDeliveries` e
+ * `useRequests` in App.tsx — subito, perché servono ai badge della prima colonna — e la
+ * Panoramica riceve quelle stesse liste. Rifare le query qui vorrebbe dire due sorgenti per lo
+ * stesso numero, cioè una delle due sempre vecchia.
+ */
+import { useCallback, useEffect, useState } from "react";
+export function useStorage(active) {
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [busy, setBusy] = useState(false);
+    const load = useCallback(async (fresh = false) => {
+        setBusy(true);
+        try {
+            setData(await getJson(`/admin/api/storage${fresh ? "?fresh=1" : ""}`));
+            setError(null);
+        }
+        catch (e) {
+            setError(message(e));
+        }
+        finally {
+            setBusy(false);
+        }
+    }, []);
+    /* Pigro come la home e i media, non immediato come le richieste: qui non c'è nessun badge
+       che debba esistere prima di entrare, e contare un bucket intero non si fa per niente. */
+    useEffect(() => { if (active && !data)
+        void load(); }, [active, data, load]);
+    return { data, error, busy, load };
+}
+export function useAnalytics(active) {
+    const [range, setRange] = useState("7d");
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [busy, setBusy] = useState(false);
+    const load = useCallback(async (want, fresh = false) => {
+        setBusy(true);
+        try {
+            setData(await getJson(`/admin/api/analytics?range=${want}${fresh ? "&fresh=1" : ""}`));
+            setError(null);
+        }
+        catch (e) {
+            /* `data` resta: cambiando periodo con Umami irraggiungibile, il grafico di prima è
+               un'informazione vecchia ma vera, e l'errore lo dice sopra. Svuotarlo lascerebbe un
+               riquadro bianco al posto di qualcosa che si stava guardando. */
+            setError(message(e));
+        }
+        finally {
+            setBusy(false);
+        }
+    }, []);
+    useEffect(() => { if (active)
+        void load(range); }, [active, range, load]);
+    return { data, error, busy, range, setRange, reload: () => load(range, true) };
+}
+async function getJson(url) {
+    const res = await fetch(url, { cache: "no-store" });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok || body.ok === false)
+        throw new Error(body.error || `HTTP ${res.status}`);
+    return body;
+}
+function message(e) { return e instanceof Error ? e.message : String(e); }

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

@@ -0,0 +1,24 @@
+export type PageModel = Record<string, unknown> & {
+    slug: string;
+    _orig?: string | null;
+    /** Versione del file da cui questa pagina è stata letta. Torna al server nel salvataggio: se
+     *  nel frattempo il file è cambiato, il server rifiuta invece di sovrascrivere. */
+    _sha?: string;
+};
+export declare function usePages(): {
+    pages: PageModel[] | null;
+    error: string | null;
+    dirty: boolean;
+    saving: boolean;
+    notice: string | null;
+    load: () => Promise<void>;
+    update: (next: PageModel[]) => void;
+    refresh: (next: PageModel) => void;
+    isPristine: (slug: string) => boolean;
+    save: () => Promise<void>;
+    setNotice: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+};
+export declare function legacyDraft(): number | null;
+/** I titoli che la bozza contiene, per poterla guardare prima di buttarla. */
+export declare function legacyDraftTitles(): string[];
+export declare function discardLegacyDraft(): void;

package/dist/app/lib/pages.js

@@ -0,0 +1,156 @@
+/* Stato dell'elenco pagine: caricamento dal repo, riordino, salvataggio.
+ *
+ * Due scelte da non perdere:
+ * 1. la sorgente autorevole è il REPO, letto da `GET /admin/api/pages`. Prima era `/index.json`,
+ *    cioè il sito pubblicato: indietro di una build, quindi capace di far riscrivere una pagina
+ *    con valori vecchi di minuti. Vedi ADMIN.md §3;
+ * 2. non si scrivono bozze in localStorage. Una bozza vive in UN browser, può essere vecchia di
+ *    giorni, e avendo la precedenza bastava rinominare una pagina per rimandare al server uno
+ *    stato stantio. Se ne trova una del vecchio admin la si mostra in sola lettura.
+ */
+import { useCallback, useEffect, useRef, useState } from "react";
+import { api, ApiError, storageKey } from "../../index.js";
+import { site } from "../site.js";
+export function usePages() {
+    const [pages, setPages] = useState(null);
+    /* Le pagine COM'ERANO quando sono state caricate, per riferimento. Serve a distinguere quelle
+     * che l'utente ha toccato da quelle che si porta dietro solo perché stanno nell'elenco: le
+     * seconde vengono spedite senza contenuto, e il server tiene quello che c'è nel file
+     * (`keepIfAbsent`). Senza, un elenco vecchio di qualche minuto riscrive con valori vecchi
+     * pagine che nessuno ha aperto. */
+    const base = useRef(new Map());
+    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 d = await api.pages();
+            /* Il modello lo costruisce il server leggendo il file con lo schema: qui non si
+             * interpreta più niente. Prima arrivava il front matter grezzo minuscolizzato da Hugo e
+             * andava riconciliato con `modelFromRaw` — un passaggio in meno, e una grafia in meno da
+             * far combaciare. L'ordine per peso lo dà già il server. */
+            const list = (d.pages ?? []).map((p) => ({
+                ...p.page, slug: p.slug, url: p.url, _orig: p.slug, _sha: p.sha,
+            }));
+            base.current = new Map(list.map((p) => [p.slug, p]));
+            setPages(list);
+            setDirty(false);
+            setError(null);
+        }
+        catch (e) {
+            setError(e instanceof ApiError ? e.message : String(e));
+        }
+    }, []);
+    useEffect(() => { void load(); }, [load]);
+    const update = useCallback((next) => {
+        next.forEach((p, i) => { p.weight = site().positionWeight(p, i, next); });
+        setPages(next);
+        setDirty(true);
+    }, []);
+    /* Sostituisce una pagina con la versione appena letta dal repo, SENZA sporcare il pannello:
+     * non è una modifica dell'utente, è la stessa pagina vista da più vicino. Aggiorna anche il
+     * riferimento, così resta "non toccata" finché non la tocca davvero qualcuno. */
+    const refresh = useCallback((next) => {
+        base.current.set(next.slug, next);
+        setPages((prev) => prev?.map((p) => (p.slug === next.slug ? next : p)) ?? null);
+    }, []);
+    /** Vero se la pagina è ancora quella caricata: nessuno l'ha modificata in questa sessione. */
+    const isPristine = useCallback((slug) => {
+        const list = pages;
+        const now = list?.find((p) => p.slug === slug);
+        return !!now && base.current.get(slug) === now;
+    }, [pages]);
+    const save = useCallback(async () => {
+        if (!pages)
+            return;
+        setSaving(true);
+        setNotice(null);
+        try {
+            /* Le pagine NON toccate si spediscono senza contenuto: solo identità e posizione. Il
+             * server, per ogni campo assente, tiene quello che c'è nel file — è esattamente ciò per
+             * cui esiste `keepIfAbsent`. `inMenu` va mandato comunque: è lui a decidere in quale
+             * gruppo cade il peso calcolato dalla posizione.
+             *
+             * `_sha` viaggia in ENTRAMBE le forme, ed è la differenza con prima: dice al server da
+             * quale versione del file siamo partiti. Se nel frattempo quel file è cambiato — l'altra
+             * scheda aperta sulla stessa pagina, il caso che ADMIN.md §3 dichiarava scoperto — il
+             * server rifiuta invece di sovrascrivere. */
+            const payload = pages.map((p) => base.current.get(p.slug) === p
+                ? { slug: p.slug, _orig: p._orig, _sha: p._sha, inMenu: p.inMenu }
+                : p);
+            const r = await api.savePages(payload);
+            setNotice(`Salvato — ${r.files} file`);
+            setDirty(false);
+            /* Il file adesso contiene ciò che ha questa pagina, quindi la sua versione è un'altra: il
+             * server rimanda gli `sha` nuovi. Senza, il salvataggio successivo partirebbe da una
+             * versione che non esiste più e verrebbe rifiutato — un pannello che si blocca da solo
+             * dopo il primo salvataggio. */
+            pages.forEach((p) => {
+                p._orig = p.slug;
+                const s = r.shas?.[p.slug];
+                if (s)
+                    p._sha = s;
+            });
+            // Da qui in poi il file contiene ciò che hanno queste pagine: tornano tutte "non toccate".
+            base.current = new Map(pages.map((p) => [p.slug, p]));
+        }
+        catch (e) {
+            const err = e;
+            setNotice(err.code === "conflict" ? "Il sito è stato modificato altrove. Ricarica e riprova."
+                : err.code === "unauthenticated" ? "Sessione scaduta: ricarica la pagina per rientrare."
+                    // `unreadable` e `invalid` arrivano già con il nome della pagina e il campo da
+                    // sistemare: il prefisso generico li allungherebbe senza aggiungere niente.
+                    : err.code === "unreadable" || err.code === "invalid" || err.code === "stale" ? err.message
+                        : `Salvataggio non riuscito: ${err.message}`);
+        }
+        finally {
+            setSaving(false);
+        }
+    }, [pages]);
+    return { pages, error, dirty, saving, notice, load, update, refresh, isPristine, save, setNotice };
+}
+/* Bozza lasciata dal VECCHIO pannello nel localStorage di questo browser: si mostra, non si usa.
+ *
+ * Perché si mostra invece di ignorarla in silenzio: era l'unico posto in cui poteva esserci una
+ * modifica mai pubblicata, e buttarla senza dirlo sarebbe stato perderla. Perché non si usa: una
+ * bozza vive in UN browser solo, può essere vecchia di giorni e non conoscere campi aggiunti nel
+ * frattempo — e avendo la precedenza bastava rinominare una pagina per rimandare al server uno
+ * stato stantio. È già successo.
+ *
+ * Nessuno scrive più queste chiavi: possono solo essere resti del pannello precedente. */
+const LEGACY_KEYS = ["pages_draft", "pages_orphan"].map(storageKey);
+export function legacyDraft() {
+    try {
+        const raw = LEGACY_KEYS.map((k) => localStorage.getItem(k)).find(Boolean);
+        if (!raw)
+            return null;
+        const d = JSON.parse(raw);
+        return Array.isArray(d) ? d.length : Array.isArray(d?.pages) ? d.pages.length : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** I titoli che la bozza contiene, per poterla guardare prima di buttarla. */
+export function legacyDraftTitles() {
+    try {
+        const raw = LEGACY_KEYS.map((k) => localStorage.getItem(k)).find(Boolean);
+        if (!raw)
+            return [];
+        const d = JSON.parse(raw);
+        const list = Array.isArray(d) ? d : Array.isArray(d?.pages) ? d.pages : [];
+        return list.map((p) => String(p?.title ?? p?.slug ?? "?"));
+    }
+    catch {
+        return [];
+    }
+}
+/* Un avviso su cui non si può agire diventa arredamento, e chi lo vede tutti i giorni smette di
+ * leggere anche i successivi. Da qui si butta. */
+export function discardLegacyDraft() {
+    try {
+        LEGACY_KEYS.forEach((k) => localStorage.removeItem(k));
+    }
+    catch { /* niente da fare */ }
+}

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

@@ -0,0 +1,18 @@
+export interface PublishState {
+    /** Quanti commit ci sono sulla bozza che non sono ancora online. */
+    ahead: number;
+    /** I loro messaggi, dal più recente: rispondono a «cosa sto mandando online?». */
+    commits: {
+        message: string;
+        date: string | null;
+    }[];
+    /** Falso se il branch di bozza non esiste ancora (passo manuale di configurazione). */
+    configured: boolean;
+    publishing: boolean;
+    notice: string | null;
+    error: string | null;
+    reload(): Promise<void>;
+    publish(): Promise<void>;
+    clearNotice(): void;
+}
+export declare function usePublish(): PublishState;

package/dist/app/lib/publish.js

@@ -0,0 +1,63 @@
+/* Quanto c'è di salvato ma non ancora online, e il gesto per mandarcelo.
+ *
+ * Salvare e pubblicare erano la stessa cosa; ora sono due, e questo stato tiene la seconda. Il
+ * conteggio delle modifiche in attesa è ciò che rende il pulsante leggibile: «Pubblica» da solo
+ * non dice se c'è qualcosa da pubblicare, e un pulsante che si può premere a vuoto insegna a
+ * premerlo a caso.
+ */
+import { useCallback, useEffect, useState } from "react";
+import { api, ApiError } from "../../index.js";
+export function usePublish() {
+    const [ahead, setAhead] = useState(0);
+    const [commits, setCommits] = useState([]);
+    const [configured, setConfigured] = useState(true);
+    const [publishing, setPublishing] = useState(false);
+    const [notice, setNotice] = useState(null);
+    const [error, setError] = useState(null);
+    const reload = useCallback(async () => {
+        try {
+            const d = await api.publishState();
+            setAhead(d.ahead ?? 0);
+            setCommits(d.commits ?? []);
+            setConfigured(d.configured !== false);
+            setError(d.configured === false ? d.error ?? null : null);
+        }
+        catch (e) {
+            // Non si azzera il conteggio su errore: mostrare «niente da pubblicare» perché una
+            // richiesta è fallita è la bugia peggiore che questo pannello possa dire.
+            setError(e instanceof ApiError ? e.message : String(e));
+        }
+    }, []);
+    /* Carica SUBITO, non entrando in una sezione: il numero di modifiche in attesa è il motivo
+     * per cui uno guarda quel pulsante, e un conteggio che compare solo dopo esserci passati sopra
+     * non serve a niente. È la stessa ragione dei badge di Richieste e Consegne. */
+    useEffect(() => { void reload(); }, [reload]);
+    const publish = useCallback(async () => {
+        setPublishing(true);
+        setNotice(null);
+        try {
+            const r = await api.publish();
+            if (r.published === false) {
+                setNotice(r.message ?? "Non c'era niente di nuovo da pubblicare.");
+            }
+            else {
+                /* L'attesa esiste ancora, ed è QUI: è l'unico punto del pannello in cui una cosa
+                 * richiede minuti, ed è giusto che sia il momento in cui si manda online. Dirlo evita
+                 * il ricaricamento nervoso che era il modo in cui si rompevano le cose. */
+                setNotice("Pubblicato. Il sito si aggiorna fra un paio di minuti.");
+            }
+            await reload();
+        }
+        catch (e) {
+            const err = e;
+            setNotice(err.code === "diverged" ? err.message : `Pubblicazione non riuscita: ${err.message}`);
+        }
+        finally {
+            setPublishing(false);
+        }
+    }, [reload]);
+    return {
+        ahead, commits, configured, publishing, notice, error,
+        reload, publish, clearNotice: () => setNotice(null),
+    };
+}

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

@@ -0,0 +1,3 @@
+export declare function movedOpenIndex(openAt: number | null, from: number, to: number): number | null;
+/** Quale card resta aperta dopo aver eliminato quella in posizione `index`. */
+export declare function removedOpenIndex(openAt: number | null, index: number): number | null;

package/dist/app/lib/reorder.js

@@ -0,0 +1,31 @@
+/* Dove finisce la card aperta quando si sposta un elemento da `from` a `to`.
+ *
+ * Serve agli elenchi le cui chiavi di drag & drop sono POSIZIONALI (`lavoro-3`, `edizione-2`):
+ * i lavori del portfolio e le edizioni dei workshop non hanno un `id` nel front matter, e non
+ * glielo si aggiunge — sarebbe un campo in più in ogni file di contenuto solo per far
+ * funzionare l'interfaccia.
+ *
+ * Il prezzo di quella scelta è tutto qui: «quale card è aperta» non può essere una chiave,
+ * perché dopo un riordino l'indice punterebbe a un altro elemento. È aritmetica con quattro
+ * casi limite, quindi vive da sola e si verifica da sola (test/portfolio-works.test.js), invece
+ * che trascinando card a mano in due editor diversi.
+ */
+export function movedOpenIndex(openAt, from, to) {
+    if (openAt === null)
+        return null;
+    if (openAt === from)
+        return to; // si sposta proprio quella aperta
+    if (openAt > from && openAt <= to)
+        return openAt - 1; // scavalcata verso il basso
+    if (openAt < from && openAt >= to)
+        return openAt + 1; // scavalcata verso l'alto
+    return openAt; // fuori dal tratto rimescolato
+}
+/** Quale card resta aperta dopo aver eliminato quella in posizione `index`. */
+export function removedOpenIndex(openAt, index) {
+    // Eliminando la card aperta non se ne apre un'altra al suo posto: quello che resta sotto non
+    // è la cosa che si stava guardando.
+    if (openAt === null || openAt === index)
+        return null;
+    return openAt > index ? openAt - 1 : openAt;
+}

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

@@ -0,0 +1,10 @@
+import { type ContactRequestRow } from "../../index.js";
+export declare function useRequests(): {
+    rows: ContactRequestRow[] | null;
+    error: string | null;
+    busy: boolean;
+    pending: number;
+    load: () => Promise<void>;
+    mark: (ids: number[], handled: boolean) => Promise<void>;
+    remove: (ids: number[]) => Promise<void>;
+};

package/dist/app/lib/requests.js

@@ -0,0 +1,67 @@
+/* Le richieste dal form di contatto.
+ *
+ * L'archivio è la SORGENTE, non l'email: `functions/api/contact.js` salva PRIMA e manda dopo, e
+ * se l'invio fallisce chi ha scritto vede comunque la conferma. Quindi questo elenco è il posto
+ * in cui una richiesta esiste davvero, e va guardato.
+ *
+ * A differenza di home e media, questo si carica SUBITO e non quando si entra nella sezione: il
+ * pallino «da gestire» nella prima colonna è tutto il motivo per cui uno ci entra. Un badge che
+ * compare solo dopo essere andati a guardare non serve a niente. È una query sola su D1.
+ */
+import { useCallback, useEffect, useState } from "react";
+import { api, ApiError } from "../../index.js";
+export function useRequests() {
+    const [rows, setRows] = useState(null);
+    const [error, setError] = useState(null);
+    const [busy, setBusy] = useState(false);
+    const load = useCallback(async () => {
+        try {
+            setRows((await api.requests()).requests);
+            setError(null);
+        }
+        catch (e) {
+            setError(e instanceof ApiError ? e.message : String(e));
+        }
+    }, []);
+    useEffect(() => { void load(); }, [load]);
+    /* Aggiornamenti FUNZIONALI: due click ravvicinati finiscono nello stesso batch di React e
+     * leggerebbero lo stesso stato vecchio, quindi il secondo cancellerebbe il primo. */
+    const mark = useCallback(async (ids, handled) => {
+        setBusy(true);
+        try {
+            await Promise.all(ids.map((id) => api.markRequest(id, handled)));
+            const at = handled ? new Date().toISOString() : null;
+            setRows((prev) => prev?.map((r) => (ids.includes(r.id) ? { ...r, handled_at: at } : r)) ?? null);
+        }
+        catch (e) {
+            setError(e instanceof ApiError ? e.message : String(e));
+        }
+        finally {
+            setBusy(false);
+        }
+    }, []);
+    /* Niente cestino, a differenza dei media: una richiesta è un testo di poche righe e chi la
+     * elimina lo sta facendo dopo averla letta. Ma una conferma sì — è l'unica copia. */
+    const remove = useCallback(async (ids) => {
+        if (!ids.length)
+            return;
+        const msg = ids.length === 1
+            ? "Eliminare questa richiesta? Non è recuperabile."
+            : `Eliminare ${ids.length} richieste? Non sono recuperabili.`;
+        if (!confirm(msg))
+            return;
+        setBusy(true);
+        try {
+            await Promise.all(ids.map((id) => api.deleteRequest(id)));
+            setRows((prev) => prev?.filter((r) => !ids.includes(r.id)) ?? null);
+        }
+        catch (e) {
+            setError(e instanceof ApiError ? e.message : String(e));
+        }
+        finally {
+            setBusy(false);
+        }
+    }, []);
+    const pending = rows?.filter((r) => !r.handled_at).length ?? 0;
+    return { rows, error, busy, pending, load, mark, remove };
+}

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

@@ -0,0 +1 @@
+export declare function useHashRoute(): [string[], (to: string) => void];

package/dist/app/lib/router.js

@@ -0,0 +1,14 @@
+/* Router a hash. Resta a hash di proposito: senza, servirebbe una regola di rewrite SPA lato
+ * Pages e una configurazione di routing in più da tenere allineata alla policy Access. Una cosa
+ * in meno che può rompersi in produzione. */
+import { useEffect, useState } from "react";
+export function useHashRoute() {
+    const read = () => location.hash.replace(/^#\/?/, "").split("/").filter(Boolean);
+    const [parts, setParts] = useState(read);
+    useEffect(() => {
+        const on = () => setParts(read());
+        addEventListener("hashchange", on);
+        return () => removeEventListener("hashchange", on);
+    }, []);
+    return [parts, (to) => { location.hash = to; }];
+}

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

@@ -0,0 +1,29 @@
+export interface SiteFeatures {
+    analytics: boolean;
+    appointments: boolean;
+}
+export interface SiteSettings {
+    siteTitle: string;
+    shortDescription: string;
+    favicon: string;
+    ownerName: string;
+    siteDescription: string;
+    seoWebsiteTitle: string;
+    searchEngineIndexing: boolean;
+    blockAiTraining: boolean;
+    analyticsTag: string;
+    features: SiteFeatures;
+    passwordEnabled: boolean;
+    password: string;
+}
+export declare function useSiteSettings(active: boolean): {
+    data: SiteSettings | null;
+    error: string | null;
+    dirty: boolean;
+    saving: boolean;
+    notice: string | null;
+    load: () => Promise<void>;
+    change: (next: SiteSettings) => void;
+    save: () => Promise<void>;
+    setNotice: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+};