@cardinali-studio/adminkit 2.2.11 → 2.2.13

package/dist/form/media/useMediaLibrary.js

@@ -9,14 +9,18 @@
  * una sola implementazione, due impaginazioni.
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { api, uploadQueue, ApiError } from "../../api.js";
+import { api, ApiError } from "../../api.js";
 import { storageKey } from "../../config.js";
 import { contentPersistenceMode } from "../../app/site.js";
+import { startMediaUpload, useMediaUploadCompletions } from "./media-upload-queue.js";
+import { invalidMediaMoveReason, isValidMediaMoveDestination, mediaFolderSlug, mediaSelectableItems, mediaSelectionState, normalizeMediaSelection, summarizeMediaSelection, tryBeginMediaMutation, } from "./media-model.js";
+import { executeMediaMovePlan, mediaMoveConfirmation, mediaMoveNeedsConfirmation, } from "./media-move.js";
 /* Quanti file per richiesta nelle operazioni lunghe (cestina, sposta). Ogni file costa al
  * server tre operazioni su R2 — legge, riscrive altrove, cancella — su oggetti da qualche MB.
  * Dieci tiene una richiesta sotto i pochi secondi, che è la soglia oltre la quale chi guarda
  * pensa che sia bloccato. Alzarlo fa tornare il difetto: richieste lunghe che muoiono a metà. */
 const CHUNK = 10;
+const MOVE_CONFIRM_FILE_THRESHOLD = 2;
 export const SORT_LABELS = {
     uploaded: "caricamento", capturedAt: "scatto", name: "nome", size: "peso",
 };
@@ -33,12 +37,32 @@ export function useMediaLibrary({ mode, multiple = true, active = true, remember
     const [subfolders, setSubfolders] = useState([]);
     const [selected, setSelected] = useState(new Set());
     const [busy, setBusy] = useState(false);
+    const [operationState, setOperationState] = useState("idle");
     const [loaded, setLoaded] = useState(false);
     const [error, setError] = useState(null);
     const [mediaOperations, setMediaOperations] = useState([]);
     const [progress, setProgress] = useState(null);
     const [uploadOpen, setUploadOpen] = useState(false);
     const [viewing, setViewing] = useState(null);
+    const [autoWebp, setAutoWebpState] = useState(true);
+    const [settingsBusy, setSettingsBusy] = useState(false);
+    const [settingsLoaded, setSettingsLoaded] = useState(false);
+    const mediaUploadCompletions = useMediaUploadCompletions();
+    const seenMediaUploadCompletions = useRef(mediaUploadCompletions);
+    /* Lo stato React disabilita la UI; la ref chiude anche la finestra nello stesso batch React,
+     * prima che il render successivo possa applicare i disabled. */
+    const mutationRef = useRef(false);
+    const mutating = operationState !== "idle";
+    const beginMutation = useCallback((state) => {
+        if (!tryBeginMediaMutation(mutationRef))
+            return false;
+        setOperationState(state);
+        return true;
+    }, []);
+    const endMutation = useCallback(() => {
+        mutationRef.current = false;
+        setOperationState("idle");
+    }, []);
     // Le preferenze di ordinamento restano dov'erano — il prefisso che il sito dichiara al
     // bootstrap ricostruisce le chiavi di prima: la memoria muscolare di chi usa il pannello
     // tutti i giorni non ha motivo di azzerarsi per una riorganizzazione dei sorgenti.
@@ -125,6 +149,31 @@ export function useMediaLibrary({ mode, multiple = true, active = true, remember
         void load(start, true);
     }, [active, loaded, busy, error, load, remember]);
     useEffect(() => { localStorage.setItem(storageKey("sortKey"), sortKey); localStorage.setItem(storageKey("sortDir"), sortDir); }, [sortKey, sortDir]);
+    /* Questa preferenza è del SITO, non del browser: il backend la conserva nel bucket Media.
+     * Finché non arriva la risposta vale il default ON, così anche i siti già esistenti hanno il
+     * nuovo comportamento senza migrazioni. Si carica solo nella vista di gestione: il picker non
+     * offre upload e non deve fare una richiesta che non userà. */
+    useEffect(() => {
+        if (mode !== "manage" || !active || settingsLoaded)
+            return;
+        setSettingsBusy(true);
+        void api.mediaSettings()
+            .then((result) => { setAutoWebpState(result.settings.autoWebp); setSettingsLoaded(true); })
+            .catch((e) => setError(e instanceof ApiError ? e.message : String(e)))
+            .finally(() => setSettingsBusy(false));
+    }, [mode, active, settingsLoaded]);
+    /* Un upload può finire mentre si guarda un'altra sezione. Al ritorno ricarichiamo la
+     * cartella corrente una volta sola, senza riportare l'utente nella cartella in cui il job era
+     * partito. Lo stato della coda è esterno a React, quindi sopravvive alla navigazione. */
+    useEffect(() => {
+        if (!active || seenMediaUploadCompletions.current === mediaUploadCompletions)
+            return;
+        seenMediaUploadCompletions.current = mediaUploadCompletions;
+        // Se nel frattempo c'è una mutazione, il suo reload finale comprende anche l'upload appena
+        // concluso. Un secondo load qui potrebbe invece cambiare busy e selezione a metà progresso.
+        if (loaded && !mutationRef.current)
+            void load(prefix);
+    }, [active, mediaUploadCompletions, loaded, load, prefix]);
     /* Chiudere o ricaricare mentre un'operazione è in corso la interrompe: il gruppo in volo non
      * arriva mai. Ora ogni gruppo è definitivo, quindi si perde poco — ma vale comunque la pena
      * chiedere, perché è esattamente il gesto che uno fa quando "non sta succedendo niente". */
@@ -143,11 +192,18 @@ export function useMediaLibrary({ mode, multiple = true, active = true, remember
             return (x < y ? -1 : x > y ? 1 : 0) * dir;
         });
     }, [files, sortKey, sortDir, mode]);
+    const selectableItems = useMemo(() => mediaSelectableItems({ mode, prefix, shown, subfolders }), [mode, prefix, shown, subfolders]);
+    const selectableIds = useMemo(() => selectableItems.map((item) => item.id), [selectableItems]);
+    const selectableIdSet = useMemo(() => new Set(selectableIds), [selectableIds]);
+    const { allSelected, someSelected } = useMemo(() => mediaSelectionState(selectableIds, selected), [selectableIds, selected]);
+    const selectionSummary = useMemo(() => summarizeMediaSelection(selected), [selected]);
     /* Aggiornamento FUNZIONALE, non `setSelected(new Set(selected))`: due click ravvicinati
      * finiscono nello stesso batch di React e leggerebbero entrambi lo stesso stato vecchio,
      * quindi il secondo cancellerebbe il primo. Con un umano che clicca piano non si vedrebbe
      * quasi mai — motivo per cui è un bug peggiore, non migliore. */
     const toggle = useCallback((key) => {
+        if (mutationRef.current || !selectableIdSet.has(key))
+            return;
         setSelected((prev) => {
             const next = new Set(prev);
             if (next.has(key))
@@ -159,40 +215,69 @@ export function useMediaLibrary({ mode, multiple = true, active = true, remember
             }
             return next;
         });
-    }, [multiple, mode]);
+    }, [multiple, mode, selectableIdSet]);
     /* «Seleziona tutto» prende anche le SOTTOCARTELLE mostrate, non solo le foto: sono lì, si
      * vedono, e sarebbe strano che «tutto» ne escludesse una parte. Nel modale di scelta no —
      * là si scelgono foto. */
     const setAll = useCallback((on) => {
+        if (mutationRef.current)
+            return;
         if (!on)
             return setSelected(new Set());
-        const ids = mode === "manage" ? subfolders.map((f) => f.prefix) : [];
-        setSelected(new Set([...ids, ...shown.map((f) => f.key)]));
-    }, [shown, subfolders, mode]);
+        setSelected(new Set(selectableIds));
+    }, [selectableIds]);
     const upload = useCallback(async (list) => {
+        if (mutationRef.current)
+            return false;
         const arr = Array.from(list);
         if (!arr.length)
             return true;
-        setProgress({ done: 0, total: arr.length, verb: "Carico" });
-        const errs = [];
+        let convert = autoWebp;
+        /* Evita la piccola finestra fra apertura dei Media e arrivo dell'impostazione: se sul sito
+           la conversione è OFF, un upload immediato non deve partire col default ON. */
+        if (!settingsLoaded) {
+            try {
+                const result = await api.mediaSettings();
+                convert = result.settings.autoWebp;
+                setAutoWebpState(convert);
+                setSettingsLoaded(true);
+            }
+            catch (e) {
+                setError(e instanceof ApiError ? e.message : String(e));
+                return false;
+            }
+        }
+        const destination = prefix
+            ? seenLabels.current[prefix] || prefix.replace(/\/$/, "").split("/").pop() || prefix
+            : "Senza cartella";
+        startMediaUpload({
+            prefix,
+            title: `${arr.length} file · ${destination}`,
+            files: arr,
+            autoWebp: convert,
+        });
+        return true;
+    }, [prefix, autoWebp, settingsLoaded]);
+    const setAutoWebp = useCallback(async (on) => {
+        if (mutationRef.current)
+            return;
+        const previous = autoWebp;
+        setAutoWebpState(on);
+        setSettingsBusy(true);
+        setError(null);
         try {
-            await uploadQueue(prefix, arr, (done, total, _r, err) => {
-                setProgress({ done, total, verb: "Carico" });
-                if (err)
-                    errs.push(err);
-            });
+            const result = await api.saveMediaSettings(on);
+            setAutoWebpState(result.settings.autoWebp);
+            setSettingsLoaded(true);
+        }
+        catch (e) {
+            setAutoWebpState(previous);
+            setError(e instanceof ApiError ? e.message : String(e));
         }
         finally {
-            setProgress(null);
-            // SEMPRE, anche se qualcosa è fallito: dopo un'operazione a metà l'elenco che si vede è
-            // una bugia, ed è peggio dell'errore.
-            await load(prefix);
+            setSettingsBusy(false);
         }
-        // Dopo `load`, che azzera il messaggio: prima veniva scritto e subito cancellato.
-        if (errs.length)
-            setError(`Non caricati: ${errs.join("; ")}`);
-        return errs.length === 0;
-    }, [prefix, load]);
+    }, [autoWebp]);
     const labelOf = useCallback((p) => {
         const f = folders.find((x) => x.prefix === p) ?? subfolders.find((x) => x.prefix === p);
         return f?.label || seenLabels.current[p] || p.replace(/\/$/, "").split("/").pop() || "";
@@ -211,14 +296,24 @@ export function useMediaLibrary({ mode, multiple = true, active = true, remember
         const name = prompt(`Nome della cartella${dove}`);
         if (!name || !name.trim())
             return;
+        if (!beginMutation("creating_folder"))
+            return;
+        setBusy(true);
+        let failure = null;
         try {
             await api.createFolder(parent, name.trim(), { label: name.trim() });
-            await load(prefix);
         }
         catch (e) {
-            setError(e instanceof ApiError ? e.message : String(e));
+            failure = e instanceof ApiError ? e.message : String(e);
+        }
+        finally {
+            setBusy(false);
+            await load(prefix);
+            endMutation();
+            if (failure)
+                setError(failure);
         }
-    }, [prefix, load, labelOf]);
+    }, [prefix, load, labelOf, beginMutation, endMutation]);
     /* Nella selezione convivono file e cartelle, e si riconoscono da soli: la chiave di una
      * cartella finisce con "/". Ogni operazione da qui in poi le separa in due liste. */
     const filesIn = (ids) => ids.filter((id) => !id.endsWith("/"));
@@ -241,6 +336,8 @@ export function useMediaLibrary({ mode, multiple = true, active = true, remember
     const remove = useCallback(async (ids) => {
         if (!ids.length)
             return;
+        if (!beginMutation("deleting"))
+            return;
         setBusy(true);
         // L'errore va tenuto da parte: `load` in coda azzera il messaggio, quindi va rimesso DOPO,
         // o l'operazione fallisce in silenzio e l'elenco aggiornato sembra dire che è andata bene.
@@ -318,10 +415,11 @@ export function useMediaLibrary({ mode, multiple = true, active = true, remember
             // SEMPRE, anche dopo un errore: l'elenco di prima è una bugia, perché una parte dei file
             // può essere passata davvero.
             await load(prefix);
+            endMutation();
             if (failure)
                 setError(failure);
         }
-    }, [prefix, load, labelOf]);
+    }, [prefix, load, labelOf, beginMutation, endMutation]);
     /* SPOSTARE UNA CARTELLA è spostare tutto ciò che contiene: in R2 la cartella non esiste, è un
      * pezzo di chiave. Cambia quindi l'indirizzo pubblico di ogni foto dentro, ed è per questo che
      * i riferimenti nelle pagine si riscrivono nello stesso giro — altrimenti le gallery che le
@@ -394,72 +492,96 @@ export function useMediaLibrary({ mode, multiple = true, active = true, remember
         await api.remove({ prefixes: [from] }, { skipRefs: true });
         return null;
     }, [labelOf]);
-    /* Spostare NON è solo copiare l'oggetto: la Function sposta il file dentro R2 e nello stesso
-     * giro riscrive i riferimenti /media/<vecchia> nelle pagine. Vale per i file come per le
-     * cartelle, che nella selezione stanno insieme. */
+    /* Il planning legge ed espande TUTTA la selezione prima della prima mutazione. Oltre alla
+     * relazione sorgente/destinazione controlla le collisioni già visibili e calcola il totale
+     * fisico che verrà usato sia nella conferma sia nel progresso. */
+    const planMove = useCallback(async (ids, dest) => {
+        const normalized = normalizeMediaSelection(ids);
+        const invalid = invalidMediaMoveReason(normalized.ids, dest);
+        if (invalid)
+            throw new Error(invalid);
+        if (!dest && normalized.files.length)
+            throw new Error("I file devono stare in una cartella.");
+        const directFiles = normalized.files.filter((key) => {
+            const slash = key.lastIndexOf("/");
+            return key.slice(0, slash < 0 ? 0 : slash + 1) !== dest;
+        });
+        const [destination, ...expanded] = await Promise.all([
+            normalized.folders.length ? api.assets(dest) : Promise.resolve(null),
+            ...normalized.folders.map((source) => api.assets(source, { recursive: true })),
+        ]);
+        const occupied = new Set(destination?.folders.map((folder) => folder.prefix) ?? []);
+        const plannedTargets = new Set();
+        const plannedFolders = normalized.folders.map((source, index) => {
+            const name = labelOf(source).trim();
+            const slug = mediaFolderSlug(name);
+            if (!slug)
+                throw new Error(`La cartella «${source}» non ha un nome valido.`);
+            const target = `${dest}${slug}/`;
+            if (target === source)
+                throw new Error(`La cartella «${name}» si trova già in quella posizione.`);
+            if (occupied.has(target) || plannedTargets.has(target)) {
+                throw new Error(`C'è già una cartella «${name}» nella destinazione scelta.`);
+            }
+            plannedTargets.add(target);
+            const inside = expanded[index];
+            return { source, name, target, files: inside.files ?? [], folders: inside.folders ?? [] };
+        });
+        if (!directFiles.length && !plannedFolders.length)
+            throw new Error("Nessun elemento da spostare.");
+        return {
+            directFiles,
+            folders: plannedFolders,
+            totalFiles: directFiles.length + plannedFolders.reduce((total, folder) => total + folder.files.length, 0),
+        };
+    }, [labelOf]);
+    /* Spostare NON è solo copiare l'oggetto: il batch conserva gli originali, accumula una sola
+     * mappa dei riferimenti e la applica soltanto dopo che TUTTE le copie sono riuscite. Al primo
+     * errore il ciclo si ferma: gli elementi non ancora iniziati non vengono toccati. */
     const move = useCallback(async (ids, dest) => {
-        if (!ids.length)
+        if (!ids.length || !beginMutation("planning"))
             return;
-        const keys = filesIn(ids);
-        const prefixes = foldersIn(ids);
         setBusy(true);
+        setError(null);
         let failure = null;
         try {
-            for (const p of prefixes) {
-                const err = await moveFolder(p, dest);
-                if (err)
-                    failure = err;
-            }
-            if (keys.length) {
-                // La radice non è una destinazione valida per un FILE: la Function la rifiuta, e senza
-                // questo controllo il rifiuto arriverebbe come un errore criptico a metà operazione.
-                if (!dest) {
-                    failure = "Le foto devono stare in una cartella.";
-                }
-                else {
-                    setProgress({ done: 0, total: keys.length, verb: "Sposto" });
-                    // A gruppi per la stessa ragione della cancellazione. Ogni gruppo COPIA conservando
-                    // gli originali e restituisce la mappa scelta dal server; la chiamata finale aggiorna
-                    // i riferimenti in un commit solo e soltanto dopo elimina gli originali.
-                    let done = 0;
-                    const urlMap = {};
-                    const copyFailures = [];
-                    for (let i = 0; i < keys.length; i += CHUNK) {
-                        const group = keys.slice(i, i + CHUNK);
-                        const r = await api.move(group, dest, { skipRefs: true });
-                        Object.assign(urlMap, r.urlMap ?? {});
-                        copyFailures.push(...(r.failed ?? []));
-                        done += r.moved ?? 0;
-                        setProgress({ done, total: keys.length, verb: "Sposto" });
-                    }
-                    const applied = Object.keys(urlMap).length ? await api.moveApplyRefs(urlMap) : null;
-                    const cleanupFailures = applied?.failed ?? [];
-                    if (copyFailures.length || cleanupFailures.length) {
-                        failure = [
-                            copyFailures.length ? `${copyFailures.length} file non spostati` : "",
-                            cleanupFailures.length ? `${cleanupFailures.length} originali rimasti come duplicati` : "",
-                        ].filter(Boolean).join("; ") + ".";
-                    }
-                }
+            const normalized = normalizeMediaSelection(ids);
+            const plan = await planMove(normalized.ids, dest);
+            const needsConfirmation = mediaMoveNeedsConfirmation(plan, MOVE_CONFIRM_FILE_THRESHOLD);
+            if (needsConfirmation) {
+                setOperationState("awaiting_confirmation");
+                const destination = dest ? `«${labelOf(dest)}»` : "il primo livello";
+                if (!confirm(mediaMoveConfirmation(plan, destination)))
+                    return;
             }
+            setOperationState("moving");
+            await executeMediaMovePlan(plan, dest, {
+                createFolder: (parent, name, opts) => api.createFolder(parent, name, opts),
+                move: (keys, destination) => api.move(keys, destination, { skipRefs: true }),
+                applyReferences: (urlMap) => api.moveApplyRefs(urlMap),
+                removeSourceFolders: async (prefixes) => { await api.remove({ prefixes }, { skipRefs: true }); },
+            }, (done, total) => setProgress({ done, total, verb: "Sposto" }), CHUNK);
         }
         catch (e) {
-            failure = e instanceof ApiError ? e.message : String(e);
+            failure = e instanceof Error ? e.message : String(e);
         }
         finally {
             setProgress(null);
             setBusy(false);
             await load(prefix);
+            endMutation();
             if (failure)
                 setError(failure);
         }
-    }, [prefix, load, moveFolder]);
+    }, [prefix, load, labelOf, planMove, beginMutation, endMutation]);
     /* Rinominare è spostare nello stesso posto con un nome nuovo: stessa strada, stesse cautele.
      * Se il nome nuovo dà lo stesso slug (è cambiata solo una maiuscola, o un «&»), non si sposta
      * niente e si riscrive la sola etichetta. */
     const renameFolder = useCallback(async (from, label) => {
         if (!label.trim())
             return;
+        if (!beginMutation("renaming"))
+            return;
         setBusy(true);
         let failure = null;
         try {
@@ -472,15 +594,18 @@ export function useMediaLibrary({ mode, multiple = true, active = true, remember
             setProgress(null);
             setBusy(false);
             await load(prefix);
+            endMutation();
             if (failure)
                 setError(failure);
         }
-    }, [prefix, load, moveFolder]);
+    }, [prefix, load, moveFolder, beginMutation, endMutation]);
     /** Cestina una cartella con tutto quello che contiene. È `remove` con una lista di uno. */
     const removeFolder = useCallback((target) => remove([target]), [remove]);
     const resumeMedia = useCallback(async (operation) => {
         if (!operation.releaseId)
             return;
+        if (!beginMutation("journal"))
+            return;
         setBusy(true);
         setError(null);
         let failure = null;
@@ -493,13 +618,16 @@ export function useMediaLibrary({ mode, multiple = true, active = true, remember
         finally {
             setBusy(false);
             await load(prefix);
+            endMutation();
             if (failure)
                 setError(failure);
         }
-    }, [load, prefix]);
+    }, [load, prefix, beginMutation, endMutation]);
     const cancelMedia = useCallback(async (operation) => {
         if (!confirm("Annullare questa operazione Media? Le copie già preparate resteranno disponibili nella libreria."))
             return;
+        if (!beginMutation("journal"))
+            return;
         setBusy(true);
         setError(null);
         let failure = null;
@@ -512,10 +640,11 @@ export function useMediaLibrary({ mode, multiple = true, active = true, remember
         finally {
             setBusy(false);
             await load(prefix);
+            endMutation();
             if (failure)
                 setError(failure);
         }
-    }, [load, prefix]);
+    }, [load, prefix, beginMutation, endMutation]);
     const step = useCallback((delta) => {
         setViewing((i) => {
             if (i === null)
@@ -525,18 +654,26 @@ export function useMediaLibrary({ mode, multiple = true, active = true, remember
         });
     }, [shown.length]);
     return {
-        mode, multiple, prefix, folders, subfolders, shown, selected, busy, error, mediaOperations, progress,
-        sortKey, sortDir, uploadOpen, viewing,
-        go: (p) => void load(p),
-        reload: () => void load(prefix),
+        mode, multiple, prefix, folders, subfolders, shown, selected, selectableIds,
+        selectedFiles: selectionSummary.files, selectedFolders: selectionSummary.folders,
+        allSelected, someSelected, busy, mutating, operationState, error, mediaOperations, progress,
+        sortKey, sortDir, uploadOpen, viewing, autoWebp, settingsBusy,
+        go: (p) => { if (!mutationRef.current)
+            void load(p); },
+        reload: () => { if (!mutationRef.current)
+            void load(prefix); },
         toggle, setAll,
         setSort: setSortKey,
         flipDir: () => setSortDir((d) => (d === "asc" ? "desc" : "asc")),
         upload,
-        setUploadOpen,
+        setUploadOpen: (open) => { if (!open || !mutationRef.current)
+            setUploadOpen(open); },
+        setAutoWebp,
         view: setViewing,
         step,
-        move, remove, newFolder, renameFolder, removeFolder, resumeMedia, cancelMedia, labelOf,
+        move,
+        canMoveTo: (ids, dest) => !mutationRef.current && isValidMediaMoveDestination(ids, dest),
+        remove, newFolder, renameFolder, removeFolder, resumeMedia, cancelMedia, labelOf,
         clearError: () => setError(null),
     };
 }

package/dist/functions/_shared/assets.js

@@ -32,8 +32,9 @@ export function sanitizeName(name) {
 export function guessMime(key) {
   const e = (key.split(".").pop() || "").toLowerCase();
   return {
-    jpg: "image/jpeg", jpeg: "image/jpeg", png: "image/png", webp: "image/webp",
-    gif: "image/gif", avif: "image/avif", svg: "image/svg+xml",
+    jpg: "image/jpeg", jpeg: "image/jpeg", jfif: "image/jpeg", png: "image/png", webp: "image/webp",
+    gif: "image/gif", avif: "image/avif", heic: "image/heic", heif: "image/heif",
+    tif: "image/tiff", tiff: "image/tiff", bmp: "image/bmp", svg: "image/svg+xml",
     mp4: "video/mp4", webm: "video/webm", mov: "video/quicktime", pdf: "application/pdf",
   }[e] || "application/octet-stream";
 }

package/dist/functions/api/assets/folders.js

@@ -13,7 +13,8 @@ export async function onRequestGet({ env }) {
   const pending = contentPersistenceMode() === "d1" ? await d1PendingSourceKeys(env.CONTENT_DB) : await pendingSourceKeys(env.MEDIA);
   const counts = {};
   for (const k of keys) {
-    if (k.startsWith(TRASH) || k.startsWith("_pending-media/") || pending.has(k)) continue;
+    if (k.startsWith(TRASH) || k.startsWith("_pending-media/") ||
+        k.startsWith("_adminkit/") || pending.has(k)) continue;
     const slash = k.indexOf("/");
     if (slash < 0) continue; // file in root: non appartiene a una cartella
     const top = k.slice(0, slash);

package/dist/functions/api/assets/settings.js

@@ -0,0 +1,40 @@
+/* GET/POST /admin/api/assets/settings — preferenze condivise della libreria Media.
+ *
+ * Vivono nello stesso bucket delle immagini: sono per sito, visibili da qualunque browser e
+ * non richiedono un commit/build per cambiare un comportamento del solo pannello.
+ */
+import { json } from "../../_shared/assets.js";
+
+const KEY = "_adminkit/settings.json";
+const defaults = { autoWebp: true };
+
+async function read(env) {
+  const object = await env.MEDIA.get(KEY);
+  if (!object) return defaults;
+  try {
+    const stored = await object.json();
+    return { autoWebp: stored?.autoWebp !== false };
+  } catch {
+    return defaults;
+  }
+}
+
+export async function onRequestGet({ env }) {
+  if (!env.MEDIA) return json({ ok: false, error: "Binding MEDIA non configurato" }, 500);
+  return json({ ok: true, settings: await read(env) });
+}
+
+export async function onRequestPost({ request, env }) {
+  if (!env.MEDIA) return json({ ok: false, error: "Binding MEDIA non configurato" }, 500);
+  let body;
+  try { body = await request.json(); }
+  catch { return json({ ok: false, error: "JSON non valido" }, 400); }
+  if (typeof body?.autoWebp !== "boolean") {
+    return json({ ok: false, error: "autoWebp deve essere booleano" }, 400);
+  }
+  const settings = { autoWebp: body.autoWebp };
+  await env.MEDIA.put(KEY, JSON.stringify(settings), {
+    httpMetadata: { contentType: "application/json" },
+  });
+  return json({ ok: true, settings });
+}

package/dist/functions/api/assets/upload.js

@@ -22,7 +22,10 @@ export async function onRequestPost({ request, env }) {
 
   // data di scatto (EXIF) per l'ordinamento "Data scatto"
   const custom = {};
-  if (ctype === "image/jpeg") {
+  const suppliedCapturedAt = request.headers.get("X-Captured-At") || "";
+  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/.test(suppliedCapturedAt)) {
+    custom.capturedAt = suppliedCapturedAt;
+  } else if (ctype === "image/jpeg") {
     const cap = extractCapturedAt(body);
     if (cap) custom.capturedAt = cap;
   }

package/dist/functions/api/assets.js

@@ -25,7 +25,8 @@ export async function onRequestGet({ request, env }) {
     const subPrefixes = new Set();
     const files = [];
     for (const k of all) {
-      if (k.startsWith("_trash/") || k.startsWith("_pending-media/") || pending.has(k)) continue;
+      if (k.startsWith("_trash/") || k.startsWith("_pending-media/") ||
+          k.startsWith("_adminkit/") || pending.has(k)) continue;
       const rel = k.slice(prefix.length);
       const cut = rel.lastIndexOf("/");
       if (cut >= 0) {
@@ -48,7 +49,7 @@ export async function onRequestGet({ request, env }) {
   // suo `.keep` (vedi assets/folder.js). Chi non ce l'ha mostra lo slug, come sempre.
   const folders = await Promise.all(
     (listed.delimitedPrefixes || [])
-      .filter((p) => p !== "_trash/" && p !== "_pending-media/")
+      .filter((p) => p !== "_trash/" && p !== "_pending-media/" && p !== "_adminkit/")
       .map(async (p) => {
         const keep = await env.MEDIA.head(p + ".keep");
         return {
@@ -66,7 +67,7 @@ export async function onRequestGet({ request, env }) {
   // oggi. È un ripiego, non la strada normale: una volta ricaricate, il ramo non scatta più.
   const raw = (listed.objects || [])
     .filter((o) => o.key !== prefix && !o.key.endsWith("/.keep") && !o.key.endsWith("/") &&
-      !o.key.startsWith("_pending-media/") && !pending.has(o.key));
+      !o.key.startsWith("_pending-media/") && !o.key.startsWith("_adminkit/") && !pending.has(o.key));
 
   const files = await Promise.all(raw.map(async (o) => {
     const cm = o.customMetadata || {};

package/dist/functions/api/site-access.js

@@ -0,0 +1,78 @@
+import { canonicalChecksum } from "../../persistence.js";
+import { createSiteAccessVersion, D1SiteAccessRepository } from "../../site-access.js";
+import { siteAccessId } from "../site.js";
+import { json } from "../_shared/assets.js";
+
+const MAX_BODY_BYTES = 2_000;
+const id = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+function response(data, status = 200) {
+  const result = json(data, status);
+  result.headers.set("Cache-Control", "no-store");
+  return result;
+}
+
+function editor(data, env) {
+  const payload = data?.cloudflareAccess?.JWT?.payload;
+  if (payload?.sub) return { subject: String(payload.sub), label: String(payload.email || payload.name || "Admin").slice(0, 200) };
+  if (env.ADMIN_LOCAL === "1") return { subject: "local-preview", label: "Anteprima locale" };
+  throw new Error("unauthenticated");
+}
+
+function required(env) {
+  const siteId = siteAccessId();
+  if (!env.CONTENT_DB || !siteId) throw new Error("site_access_unavailable");
+  return { siteId, repository: new D1SiteAccessRepository(env.CONTENT_DB) };
+}
+
+function publicState(state) {
+  const clean = (value) => value ? { versionId: value.versionId, enabled: value.enabled, formatVersion: value.formatVersion } : null;
+  return { active: clean(state.active), draft: clean(state.draft), effective: clean(state.draft ?? state.active) };
+}
+
+function safeError(error) {
+  const code = error?.message;
+  const status = code === "unauthenticated" ? 401 : code === "invalid_request" || code === "invalid_site_access_password" ? 400
+    : code === "stale_site_access" ? 409 : 503;
+  const message = code === "unauthenticated" ? "Sessione non valida: ricarica la pagina per rientrare."
+    : code === "invalid_site_access_password" ? "La password deve contenere almeno 8 caratteri."
+      : code === "stale_site_access" ? "La protezione è stata modificata altrove: ricarica la pagina."
+        : status === 400 ? "Richiesta non valida." : "La gestione della password non è disponibile.";
+  return response({ ok: false, code: status >= 500 ? "site_access_unavailable" : code, error: message }, status);
+}
+
+export async function onRequestGet({ env, data }) {
+  try {
+    editor(data, env);
+    const { repository } = required(env);
+    await repository.initialize(Date.now());
+    return response({ ok: true, state: publicState(await repository.state()) });
+  } catch (error) { return safeError(error); }
+}
+
+export async function onRequestPost({ request, env, data }) {
+  try {
+    const origin = request.headers.get("Origin");
+    if (!origin || new URL(origin).origin !== new URL(request.url).origin) throw new Error("invalid_request");
+    if (Number(request.headers.get("Content-Length") || 0) > MAX_BODY_BYTES) throw new Error("invalid_request");
+    const raw = await request.text();
+    if (new TextEncoder().encode(raw).byteLength > MAX_BODY_BYTES) throw new Error("invalid_request");
+    const body = JSON.parse(raw);
+    const author = editor(data, env);
+    const { siteId, repository } = required(env);
+    await repository.initialize(Date.now());
+    if (body?.action === "discard") {
+      if (!id.test(body.expectedDraftVersionId || "")) throw new Error("invalid_request");
+      await repository.discard(body.expectedDraftVersionId, Date.now());
+      return response({ ok: true, discarded: true, state: publicState(await repository.state()) });
+    }
+    if (body?.action !== "save" || typeof body.enabled !== "boolean"
+      || (body.expectedDraftVersionId !== null && !id.test(body.expectedDraftVersionId || ""))) throw new Error("invalid_request");
+    const versionId = crypto.randomUUID();
+    const access = await createSiteAccessVersion({ versionId, siteId, enabled: body.enabled, password: body.password, keyring: env.SITE_ACCESS_KEYRING });
+    const requestChecksum = await canonicalChecksum({ action: "site-access.save", versionId, enabled: access.enabled, descriptorChecksum: access.descriptorChecksum });
+    await repository.saveDraft({ access, expectedDraftVersionId: body.expectedDraftVersionId, requestChecksum,
+      authorSubject: author.subject, authorLabel: author.label, now: Date.now() });
+    return response({ ok: true, saved: true, state: publicState(await repository.state()) });
+  } catch (error) { return safeError(error); }
+}