@cardinali-studio/adminkit 2.2.25 → 2.2.34

package/dist/app/lib/home.js

@@ -8,7 +8,7 @@
  * 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 { useCallback, useEffect, useState, useRef } from "react";
 import { ApiError } from "../../index.js";
 import { api } from "../../api.js";
 import { contentPersistenceMode, site } from "../site.js";
@@ -27,6 +27,7 @@ export function useHome(active) {
     const [saving, setSaving] = useState(false);
     const [notice, setNotice] = useState(null);
     const [revision, setRevision] = useState(null);
+    const pending = useRef(null);
     const load = useCallback(async () => {
         try {
             const mapped = site().homeDocument;
@@ -59,12 +60,14 @@ export function useHome(active) {
         try {
             const mapped = site().homeDocument;
             if (contentPersistenceMode() === "d1" && mapped && revision) {
-                const revisionId = crypto.randomUUID();
+                const revisionId = pending.current?.revisionId ?? crypto.randomUUID();
                 /* The Worker validates and may normalize a document before checking its signed
                  * representation. Sign the site-owned canonical payload here too, otherwise an
                  * obsolete/unknown client field becomes a misleading "documento non valido". */
                 const payload = mapped.toPayload ? mapped.toPayload(data) : data;
-                await api.saveContent({ revisionId, documentId: mapped.documentId, baseRevisionId: revision.base, expectedDraftRevisionId: revision.expected, kind: mapped.kind, locale: mapped.locale, schemaVersion: mapped.schemaVersion, payload: payload, tombstone: false });
+                pending.current ||= { revisionId, documentId: mapped.documentId, baseRevisionId: revision.base, expectedDraftRevisionId: revision.expected, kind: mapped.kind, locale: mapped.locale, schemaVersion: mapped.schemaVersion, payload: payload, tombstone: false };
+                await api.saveContent(pending.current);
+                pending.current = null;
                 setRevision({ base: revisionId, expected: revisionId });
                 setNotice("Bozza D1 salvata");
                 setDirty(false);
@@ -88,7 +91,7 @@ export function useHome(active) {
             setSaving(false);
         }
     }, [data, revision]);
-    const change = useCallback((next) => { setData(next); setDirty(true); }, []);
+    const change = useCallback((next) => { pending.current = null; setData(next); setDirty(true); }, []);
     const mapped = site().homeDocument;
     return { data, error, dirty, saving, notice, load, change, save, setNotice,
         publishTarget: contentPersistenceMode() === "d1" && mapped && revision

package/dist/app/lib/pages.js

@@ -48,7 +48,8 @@ export function usePages() {
     }, []);
     useEffect(() => { void load(); }, [load]);
     const update = useCallback((next) => {
-        next.forEach((p, i) => { p.weight = site().positionWeight(p, i, next); });
+        if (site().pagesReorderable !== false)
+            next.forEach((p, i) => { p.weight = site().positionWeight(p, i, next); });
         setPages(next);
         setDirty(true);
     }, []);

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

@@ -17,6 +17,11 @@ export interface PublishState {
     reload(): Promise<void>;
     publish(target?: ContentPublishTarget): Promise<void>;
     clearNotice(): void;
+    preview(target: ContentPublishTarget): Promise<void>;
+    previewApproved(target: ContentPublishTarget | null): boolean;
+    previousReleaseId: string | null;
+    rollback(): Promise<void>;
+    verify(): Promise<void>;
 }
 export declare function contentPublicationNotice(result: {
     published: boolean;

package/dist/app/lib/publish.js

@@ -7,7 +7,7 @@
  */
 import { useCallback, useEffect, useState } from "react";
 import { api, ApiError } from "../../index.js";
-import { contentPersistenceMode } from "../site.js";
+import { contentPersistenceMode, site } from "../site.js";
 export function contentPublicationNotice(result) {
     if (result.published === false) {
         return result.message ?? "Non c'erano modifiche salvate da pubblicare.";
@@ -25,10 +25,64 @@ export function usePublish() {
     const [publishing, setPublishing] = useState(false);
     const [notice, setNotice] = useState(null);
     const [error, setError] = useState(null);
+    const [approval, setApproval] = useState(null);
+    const [activeReleaseId, setActiveReleaseId] = useState(null);
+    const [previousReleaseId, setPreviousReleaseId] = useState(null);
+    const previewApproved = (target) => !!target && "documentId" in target && !!approval && approval.documentId === target.documentId && approval.expectedDraftRevisionId === target.expectedDraftRevisionId && approval.expectedBaseReleaseId === activeReleaseId;
+    const preview = async (target) => {
+        if (!("documentId" in target))
+            return;
+        setPublishing(true);
+        setNotice(null);
+        try {
+            const result = await api.contentPreview(target);
+            setApproval({ ...result, documentId: target.documentId });
+            window.open(result.previewUrl, "_blank", "noopener");
+            setNotice("Anteprima della bozza salvata pronta.");
+        }
+        catch (error) {
+            setApproval(null);
+            setNotice(error.message);
+        }
+        finally {
+            setPublishing(false);
+        }
+    };
+    const rollback = async () => {
+        if (!activeReleaseId || !previousReleaseId)
+            return;
+        setPublishing(true);
+        setNotice(null);
+        try {
+            await api.contentRollback(activeReleaseId, previousReleaseId);
+            setApproval(null);
+            await reload();
+            setNotice("Ripristinata la release precedente. Le bozze sono conservate.");
+        }
+        catch (error) {
+            setNotice(error.message);
+        }
+        finally {
+            setPublishing(false);
+        }
+    };
+    const verify = async () => {
+        if (!activeReleaseId)
+            return;
+        try {
+            const result = await api.contentVerification(activeReleaseId);
+            setNotice(result.publicOriginVerified ? "Release verificata sul dominio pubblico." : result.reason);
+        }
+        catch (error) {
+            setNotice(error.message);
+        }
+    };
     const reload = useCallback(async () => {
         if (contentPersistenceMode() === "d1") {
             try {
                 const d = await api.contentPublishState();
+                setActiveReleaseId(d.activeReleaseId ?? null);
+                setPreviousReleaseId(d.previousReleaseId ?? null);
                 setAhead(d.ahead ?? 0);
                 setDocuments(d.documents ?? []);
                 setSiteAccessPending(Boolean(d.siteAccess));
@@ -78,7 +132,10 @@ export function usePublish() {
             try {
                 if (!target)
                     throw new ApiError("Apri il contenuto che vuoi pubblicare.", "invalid_request", 400);
-                const r = await api.contentPublish(target);
+                if (site().directPublication && !previewApproved(target))
+                    throw new ApiError("Apri una nuova anteprima della bozza prima di pubblicare.", "stale_preview", 409);
+                const r = await api.contentPublish(site().directPublication ? { ...target, ...approval } : target);
+                setApproval(null);
                 setNotice(contentPublicationNotice(r));
                 await reload();
             }
@@ -113,9 +170,9 @@ export function usePublish() {
         finally {
             setPublishing(false);
         }
-    }, [reload]);
+    }, [reload, approval, activeReleaseId]);
     return {
         ahead, commits, documents, siteAccessPending, configured, publishing, notice, error,
-        reload, publish, clearNotice: () => setNotice(null),
+        reload, publish, preview, previewApproved, previousReleaseId, rollback, verify, clearNotice: () => setNotice(null),
     };
 }

package/dist/app/lib/requests.js

@@ -1,3 +1,4 @@
+import { site } from "../site.js";
 /* Le richieste dal form di contatto.
  *
  * L'archivio è la SORGENTE, non l'email: `functions/api/contact.js` salva PRIMA e manda dopo, e
@@ -15,6 +16,11 @@ export function useRequests() {
     const [error, setError] = useState(null);
     const [busy, setBusy] = useState(false);
     const load = useCallback(async () => {
+        if (site().modules?.requests !== true) {
+            setRows([]);
+            setError(null);
+            return;
+        }
         try {
             setRows((await api.requests()).requests);
             setError(null);

package/dist/app/lib/settings.js

@@ -4,7 +4,7 @@
  * 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 { useCallback, useEffect, useState, useRef } from "react";
 import { ApiError } from "../../index.js";
 import { api } from "../../api.js";
 import { contentPersistenceMode, site } from "../site.js";
@@ -43,6 +43,7 @@ export function useSiteSettings(active) {
         const { password: _password, passwordEnabled: _passwordEnabled, ...editorial } = settings;
         return JSON.stringify(editorial);
     };
+    const pending = useRef(null);
     const load = useCallback(async () => {
         try {
             const mapped = site().siteSettingsDocument;
@@ -88,9 +89,11 @@ export function useSiteSettings(active) {
             const mapped = site().siteSettingsDocument;
             if (contentPersistenceMode() === "d1" && mapped && revision) {
                 if (editorialSnapshot(data) !== editorialBaseline) {
-                    const revisionId = crypto.randomUUID();
+                    const revisionId = pending.current?.revisionId ?? crypto.randomUUID();
                     const payload = mapped.toPayload ? mapped.toPayload(data) : data;
-                    await api.saveContent({ revisionId, documentId: mapped.documentId, baseRevisionId: revision.base, expectedDraftRevisionId: revision.expected, kind: mapped.kind, locale: mapped.locale, schemaVersion: mapped.schemaVersion, payload: payload, tombstone: false });
+                    pending.current ||= { revisionId, documentId: mapped.documentId, baseRevisionId: revision.base, expectedDraftRevisionId: revision.expected, kind: mapped.kind, locale: mapped.locale, schemaVersion: mapped.schemaVersion, payload: payload, tombstone: false };
+                    await api.saveContent(pending.current);
+                    pending.current = null;
                     setRevision({ base: revisionId, expected: revisionId });
                     setEditorialBaseline(editorialSnapshot(data));
                 }
@@ -124,6 +127,7 @@ export function useSiteSettings(active) {
         }
     }, [data, revision, accessState, editorialBaseline]);
     const change = useCallback((next) => {
+        pending.current = null;
         setData(next);
         setDirty(true);
     }, []);

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

@@ -1,5 +1,5 @@
-import { type DeliveryUploadProgress } from "./delivery-upload";
-export type UploadState = "running" | "paused" | "done" | "failed";
+import { type DeliveryUploadProgress, type UploadControl } from "./delivery-upload.js";
+export type UploadState = "running" | "paused" | "cancelling" | "done" | "failed";
 export interface UploadJob {
     /** L'id del pacchetto: uno per caricamento. */
     id: string;
@@ -11,6 +11,8 @@ export interface UploadJob {
     progress: DeliveryUploadProgress | null;
     error?: string;
     skipped?: number;
+    waitingForNetwork?: boolean;
+    retryable?: boolean;
 }
 interface StartInput {
     deliveryId: string;
@@ -20,16 +22,32 @@ interface StartInput {
     options: {
         galleryEnabled: boolean;
         webEnabled: boolean;
+        webFormat?: "webp" | "jpg";
+        manifestVersion?: 1 | 2;
     };
 }
 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 class Gate implements UploadControl {
+    private id;
+    readonly controller: AbortController;
+    readonly signal: AbortSignal;
+    private waitingRequests;
+    constructor(id: string);
+    networkWaiting(waiting: boolean): void;
+    paused: boolean;
+    cancelled: boolean;
+    private waiting;
+    gate(): Promise<void>;
+    wake(): void;
+}
+export declare function startUpload(input: StartInput): Promise<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 retryUpload(id: string): Promise<void> | undefined;
 export declare function dismissUpload(id: string): void;
 export declare function hasRunningUploads(): boolean;
 export {};

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

@@ -15,12 +15,14 @@
  *   App.tsx         ricarica l'elenco quando uno finisce (`useUploadCompletions`)
  */
 import { useSyncExternalStore } from "react";
-import { UploadCancelled, uploadDeliveryPackage, } from "./delivery-upload";
-import { deliveryAction } from "./deliveries";
+import { UploadCancelled, uploadDeliveryPackage, } from "./delivery-upload.js";
+import { deliveryJson } from "./delivery-network.js";
 /* ---- lo stato ------------------------------------------------------------------------ */
 let jobs = [];
 let completions = 0;
 const gates = new Map();
+const running = new Map();
+const retries = new Map();
 const listeners = new Set();
 function emit() {
     jobs = [...jobs];
@@ -47,15 +49,27 @@ export function useUploadCompletions() {
     return useSyncExternalStore(subscribe, () => completions, () => completions);
 }
 export function uploadFor(deliveryId, list) {
-    return list.find((job) => job.deliveryId === deliveryId);
+    const matching = list.filter((job) => job.deliveryId === deliveryId);
+    return matching.find(isBusy) || matching[matching.length - 1];
 }
 export function isBusy(job) {
-    return !!job && (job.state === "running" || job.state === "paused");
+    return !!job && (job.state === "running" || job.state === "paused" || job.state === "cancelling");
 }
 /* ---- 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 {
+export class Gate {
+    id;
+    controller = new AbortController();
+    signal = this.controller.signal;
+    waitingRequests = 0;
+    constructor(id) {
+        this.id = id;
+    }
+    networkWaiting(waiting) {
+        this.waitingRequests += waiting ? 1 : -1;
+        patch(this.id, { waitingForNetwork: this.waitingRequests > 0 });
+    }
     paused = false;
     cancelled = false;
     waiting = [];
@@ -77,7 +91,10 @@ class Gate {
 }
 /* ---- i comandi ------------------------------------------------------------------------ */
 export function startUpload(input) {
-    const gate = new Gate();
+    const existing = running.get(input.packageId);
+    if (existing)
+        return existing;
+    const gate = new Gate(input.packageId);
     gates.set(input.packageId, gate);
     jobs = [...jobs.filter((job) => job.id !== input.packageId), {
             id: input.packageId,
@@ -89,33 +106,64 @@ export function startUpload(input) {
             progress: null,
         }];
     emit();
-    void run(input, gate);
+    const promise = run(input, gate).finally(() => running.delete(input.packageId));
+    running.set(input.packageId, promise);
+    return promise;
 }
 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);
+        const retry = retries.get(id);
+        if (retry?.cleanup)
+            throw new UploadCancelled();
+        const result = retry?.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(() => { });
+        retries.set(id, { input, result });
+        await gate.gate();
+        if (result.manifest.version === 2) {
+            let done = false;
+            while (!done) {
+                await gate.gate();
+                const step = await deliveryJson("/admin/api/deliveries", {
+                    action: "manifestFinalize", id: input.deliveryId, packageId: id,
+                }, gate);
+                done = step.done;
+            }
+        }
+        else
+            await deliveryJson("/admin/api/deliveries", {
+                action: "finalizePackage", id: input.deliveryId, packageId: id,
+                manifest: result.manifest, fileCount: result.fileCount,
+                sourceBytes: result.sourceBytes, storedBytes: result.storedBytes,
+            }, gate);
+        await gate.gate();
+        await deliveryJson("/admin/api/deliveries", { action: "activate", id: input.deliveryId, packageId: id }, gate);
+        await gate.gate();
+        retries.delete(id);
         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);
+            patch(id, { state: "cancelling", progress: null });
+            try {
+                await deliveryJson("/admin/api/deliveries", {
+                    action: "deletePackage", id: input.deliveryId, packageId: id,
+                }, { gate: async () => { }, networkWaiting: (waiting) => gate.networkWaiting(waiting) });
+                retries.delete(id);
+                jobs = jobs.filter((job) => job.id !== id);
+            }
+            catch (cleanupError) {
+                retries.set(id, { input, cleanup: true });
+                patch(id, { state: "failed", retryable: true, error: "Upload fermato. Riprova la rimozione dei file: " + readable(cleanupError) });
+            }
         }
         else {
-            patch(id, { state: "failed", progress: null, error: readable(error) });
+            if (!retries.has(id))
+                retries.set(id, { input });
+            patch(id, { state: "failed", progress: null, retryable: true, error: readable(error) });
         }
     }
     finally {
@@ -144,12 +192,21 @@ export function cancelUpload(id) {
     if (!gate)
         return;
     gate.cancelled = true;
+    gate.controller.abort();
+    patch(id, { state: "cancelling" });
     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 retryUpload(id) {
+    const retry = retries.get(id);
+    if (retry)
+        return startUpload(retry.input);
+}
 export function dismissUpload(id) {
+    if (!gates.has(id))
+        retries.delete(id);
     jobs = jobs.filter((job) => job.id === id ? isBusy(job) : true);
     emit();
 }