@cardinali-studio/adminkit 1.0.0

package/dist/app/index.d.ts

@@ -0,0 +1,18 @@
+import { type SiteAdminConfig } from "./site.js";
+export type { SiteAdminConfig } from "./site.js";
+export interface MountOptions {
+    /** Ciò che il kit non può sapere da solo: la forma dei contenuti di questo sito. */
+    site: SiteAdminConfig;
+    /** L'elemento in cui montare. Default: `#root`. */
+    root?: HTMLElement | null;
+    /**
+     * Namespace delle preferenze salvate nel browser (ordinamento dei media, ultima cartella
+     * aperta nel selettore).
+     *
+     * ⚠️ Non si cambia a cuor leggero su un sito già in uso: sono le chiavi con cui quelle
+     * preferenze sono GIÀ state scritte nei browser di chi usa il pannello, e cambiarle le azzera
+     * in silenzio. Un sito che migra al kit deve passare qui il valore che usava prima.
+     */
+    storagePrefix: string;
+}
+export declare function mountAdmin({ site, root, storagePrefix }: MountOptions): void;

package/dist/app/index.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/* L'ingresso `./app`: il pannello si monta con UNA chiamata.
+ *
+ * È opaco di proposito (DP-003). Il kit non esporta i pezzi della shell perché un sito possa
+ * assemblarsi la sua: comporre è esattamente ciò che ha prodotto la divergenza che questa
+ * estrazione ripara — il rail a gruppi e quello piatto nascono dallo stesso codice, e sono
+ * diversi solo perché ognuno poteva montarselo. Ciò che un sito cambia sono i suoi contenuti,
+ * i suoi colori e quali moduli sono accesi; non la forma del pannello.
+ *
+ * Ordine dei fogli di stile, e non è un dettaglio: il kit importa i PROPRI default
+ * (`theme.css`) e la propria impaginazione (`app.css`) da dentro `App.tsx`. Il sito importa il
+ * suo `theme.css` DOPO — cioè nel proprio `main.tsx`, dopo questo import — così i suoi valori
+ * vincono sui default senza che nessuno debba giocare con la specificità.
+ */
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import { setStoragePrefix } from "../index.js";
+import { App } from "./App.js";
+import { applyTheme, initialTheme } from "./lib/theme.js";
+import { setSiteConfig } from "./site.js";
+export function mountAdmin({ site, root, storagePrefix }) {
+    setSiteConfig(site);
+    setStoragePrefix(storagePrefix);
+    /* SINCRONO, prima del render: se il tema lo applicasse solo l'effetto dentro `App`, ci sarebbe
+     * un fotogramma con i valori chiari di default prima che React monti — visibile a chi
+     * preferisce il sistema scuro. `useTheme()` inizializza il suo stato con lo stesso
+     * `initialTheme()`, quindi il suo primo `applyTheme` è un no-op visivo, non un secondo lampo. */
+    applyTheme(initialTheme());
+    const el = root ?? document.getElementById("root");
+    if (!el)
+        throw new Error("adminkit: elemento di montaggio non trovato (atteso #root)");
+    createRoot(el).render(_jsx(StrictMode, { children: _jsx(App, {}) }));
+}

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

@@ -0,0 +1,132 @@
+export type BookingStatus = "pending" | "confirming" | "confirmed" | "rejected" | "cancelled" | "completed" | "no_show" | "expired" | "anonymized";
+export type Booking = {
+    id: string;
+    referenceCode: string;
+    appointmentTypeId: string | null;
+    typeName: string;
+    durationMinutes: number;
+    status: BookingStatus;
+    calendarSyncStatus: string;
+    visitorName: string | null;
+    visitorEmail: string | null;
+    visitorPhone: string | null;
+    visitorNotes: string | null;
+    adminNotes: string | null;
+    mode: "in_person" | "virtual";
+    location: string | null;
+    visitorTimezone: string;
+    startAt: string;
+    endAt: string;
+    googleEventUrl: string | null;
+    meetUrl: string | null;
+    source: string;
+    createdAt: string;
+};
+export type AppointmentType = {
+    id: string;
+    slug: string;
+    name: string;
+    description: string;
+    active: boolean;
+    durationMinutes: number | null;
+    bufferBeforeMinutes: number | null;
+    bufferAfterMinutes: number | null;
+    modePolicy: "in_person" | "virtual" | "both";
+    sortOrder: number;
+    adminColor: string;
+};
+export type BookingSettings = {
+    timezone: string;
+    address: string;
+    contactEmail: string;
+    contactPhone: string;
+    defaultDurationMinutes: number;
+    defaultBufferBeforeMinutes: number;
+    defaultBufferAfterMinutes: number;
+    slotStepMinutes: number;
+    minimumNoticeMinutes: number;
+    bookingHorizonDays: number;
+    dailyLimit: number;
+    weeklyLimit: number;
+    reminder1Minutes: number;
+    reminder2Minutes: number;
+    retentionDays: number;
+};
+export type AvailabilityWindow = {
+    weekday: number;
+    startMinute: number;
+    endMinute: number;
+};
+export type AvailabilityOverride = {
+    id?: string;
+    date: string;
+    kind: "closed" | "custom";
+    note?: string;
+    windows: Array<{
+        startMinute: number;
+        endMinute: number;
+    }>;
+};
+export type GoogleCalendar = {
+    id: string;
+    summary: string;
+    primary: boolean;
+    accessRole: string;
+    busy: boolean;
+    booking: boolean;
+    supportsMeet: boolean;
+};
+export type BookingBlock = {
+    id: string;
+    start_at: string;
+    end_at: string;
+    note: string;
+};
+type BookingData = {
+    rows: Booking[] | null;
+    types: AppointmentType[];
+    settings: BookingSettings | null;
+    weekly: AvailabilityWindow[];
+    overrides: AvailabilityOverride[];
+    google: {
+        connected: boolean;
+        connection: {
+            account_email?: string;
+            token_status?: string;
+        } | null;
+        calendars: GoogleCalendar[];
+    };
+    activation: {
+        enabled: boolean;
+        ready: boolean;
+        checks: Record<string, boolean>;
+    } | null;
+    blocks: BookingBlock[];
+    pending: number;
+    upcoming: number;
+    loading: boolean;
+    busy: boolean;
+    error: string | null;
+    notice: string | null;
+};
+export declare function useBookings(): BookingData & {
+    load: () => Promise<void>;
+    action: (id: string, payload: Record<string, unknown>) => Promise<void>;
+    saveSettings: (value: BookingSettings) => Promise<void>;
+    saveType: (value: Partial<AppointmentType>, create?: boolean) => Promise<void>;
+    removeType: (id: string) => Promise<void>;
+    saveAvailability: (weekly: AvailabilityWindow[], overrides: AvailabilityOverride[]) => Promise<void>;
+    saveGoogle: (busy: string[], booking: string) => Promise<void>;
+    refreshGoogle: () => Promise<void>;
+    disconnectGoogle: () => Promise<void>;
+    setEnabled: (enabled: boolean) => Promise<void>;
+    addBlock: (value: {
+        startAt: string;
+        endAt: string;
+        note: string;
+    }) => Promise<void>;
+    removeBlock: (id: string) => Promise<void>;
+    createManual: (value: Record<string, unknown>) => Promise<string | null>;
+    clearNotice: () => void;
+};
+export {};

package/dist/app/lib/bookings.js

@@ -0,0 +1,79 @@
+import { useCallback, useEffect, useState } from "react";
+async function call(path, init) {
+    const response = await fetch(`/admin/api/booking${path}`, {
+        ...init,
+        headers: { "Content-Type": "application/json", ...(init?.headers || {}) },
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok)
+        throw new Error(data.error || `Errore ${response.status}`);
+    return data;
+}
+export function useBookings() {
+    const [state, setState] = useState({
+        rows: null, types: [], settings: null, weekly: [], overrides: [],
+        google: { connected: false, connection: null, calendars: [] },
+        activation: null, blocks: [], pending: 0, upcoming: 0,
+        loading: true, busy: false, error: null, notice: null,
+    });
+    const load = useCallback(async () => {
+        setState((value) => ({ ...value, loading: true, error: null }));
+        try {
+            const [list, types, settings, availability, google, activation, blocks] = await Promise.all([
+                call(""),
+                call("/types"),
+                call("/settings"),
+                call("/availability"),
+                call("/google"),
+                call("/activation"),
+                call("/blocks"),
+            ]);
+            setState((value) => ({
+                ...value, rows: list.bookings, pending: list.counts.pending, upcoming: list.counts.upcoming,
+                types: types.types, settings: settings.settings, weekly: availability.weekly,
+                overrides: availability.overrides, google, activation, blocks: blocks.blocks,
+                loading: false, error: null,
+            }));
+        }
+        catch (error) {
+            setState((value) => ({ ...value, loading: false, error: error instanceof Error ? error.message : String(error) }));
+        }
+    }, []);
+    useEffect(() => { void load(); }, [load]);
+    const mutate = useCallback(async (task, notice) => {
+        setState((value) => ({ ...value, busy: true, error: null }));
+        try {
+            await task();
+            await load();
+            setState((value) => ({ ...value, busy: false, notice }));
+        }
+        catch (error) {
+            setState((value) => ({ ...value, busy: false, error: error instanceof Error ? error.message : String(error) }));
+            throw error;
+        }
+    }, [load]);
+    return {
+        ...state,
+        load,
+        action: (id, payload) => mutate(() => call(`/${encodeURIComponent(id)}`, { method: "PATCH", body: JSON.stringify(payload) }), "Prenotazione aggiornata."),
+        saveSettings: (value) => mutate(() => call("/settings", { method: "PUT", body: JSON.stringify(value) }), "Impostazioni salvate."),
+        saveType: (value, create = false) => mutate(() => call("/types", { method: create ? "POST" : "PUT", body: JSON.stringify(value) }), create ? "Tipologia creata." : "Tipologia aggiornata."),
+        removeType: (id) => mutate(() => call("/types", { method: "DELETE", body: JSON.stringify({ id }) }), "Tipologia archiviata."),
+        saveAvailability: (weekly, overrides) => mutate(() => call("/availability", { method: "PUT", body: JSON.stringify({ weekly, overrides }) }), "Disponibilità salvata."),
+        saveGoogle: (busy, booking) => mutate(() => call("/google", { method: "PUT", body: JSON.stringify({ busy, booking }) }), "Calendari aggiornati."),
+        refreshGoogle: () => mutate(() => call("/google", { method: "POST" }), "Elenco calendari aggiornato."),
+        disconnectGoogle: () => mutate(() => call("/google", { method: "DELETE" }), "Account Google scollegato."),
+        setEnabled: (enabled) => mutate(() => call("/activation", { method: "POST", body: JSON.stringify({ enabled }) }), enabled ? "Attivazione inviata: il sito sarà disponibile dopo il deploy." : "Disattivazione inviata."),
+        addBlock: (value) => mutate(() => call("/blocks", { method: "POST", body: JSON.stringify(value) }), "Blocco aggiunto."),
+        removeBlock: (id) => mutate(() => call("/blocks", { method: "DELETE", body: JSON.stringify({ id }) }), "Blocco rimosso."),
+        createManual: async (value) => {
+            let id = null;
+            await mutate(async () => {
+                const result = await call("", { method: "POST", body: JSON.stringify(value) });
+                id = result.booking.id;
+            }, "Appuntamento inserito; ora puoi approvarlo.");
+            return id;
+        },
+        clearNotice: () => setState((value) => ({ ...value, notice: null })),
+    };
+}

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

@@ -0,0 +1,95 @@
+export type DeliveryStatus = "draft" | "uploading" | "active" | "archived";
+export interface DeliverySummary {
+    id: string;
+    clientName: string;
+    title: string;
+    description: string;
+    licenseNotes: string;
+    ctaEnabled: boolean;
+    ctaLabel: string;
+    ctaUrl: string;
+    expiresAt: string | null;
+    filesExpiresAt: string | null;
+    status: DeliveryStatus;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+    activatedAt: string | null;
+    packageCount: number;
+    linkCount: number;
+    storedBytes: number;
+    downloadCount: number;
+}
+export interface DeliveryPackage {
+    id: string;
+    deliveryId: string;
+    label: string;
+    position: number;
+    galleryEnabled: boolean;
+    webEnabled: boolean;
+    state: "uploading" | "ready" | "failed";
+    sourceFingerprint: string;
+    fileCount: number;
+    sourceBytes: number;
+    storedBytes: number;
+    createdAt: string;
+    updatedAt: string;
+    images: DeliveryPackageImage[];
+}
+export interface DeliveryPackageImage {
+    index: number;
+    name: string;
+    previewUrl: string;
+}
+export type DeliveryHero = {
+    type: "package";
+    packageId: string;
+    index: number;
+    previewUrl: string;
+} | {
+    type: "object";
+    id: string;
+    sourceName: string;
+    width: number;
+    height: number;
+    previewUrl: string;
+};
+export interface DeliverySettings {
+    defaultHeroes: string[];
+}
+export interface DeliveryLink {
+    id: string;
+    label: string;
+    token: string;
+    pin: string | null;
+    url: string;
+    expiresAt: string | null;
+    revokedAt: string | null;
+    createdAt: string;
+    openedCount: number;
+    lastOpenedAt: string | null;
+    downloadCount: number;
+    lastDownloadAt: string | null;
+}
+export interface Delivery extends DeliverySummary {
+    packages: DeliveryPackage[];
+    links: DeliveryLink[];
+    heroes: DeliveryHero[];
+}
+export declare function useDeliveries(activeId?: string): {
+    rows: DeliverySummary[] | null;
+    detail: Delivery | null;
+    expiring: number;
+    settings: DeliverySettings;
+    error: string | null;
+    busy: boolean;
+    load: () => Promise<void>;
+    open: (id: string) => Promise<void>;
+    read: (id: string) => Promise<Delivery | null>;
+    action: <T>(payload: Record<string, unknown>, options?: {
+        reload?: boolean;
+    }) => Promise<T>;
+    refresh: () => Promise<void>;
+    setDetail: import("react").Dispatch<import("react").SetStateAction<Delivery | null>>;
+};
+export declare function deliveryAction<T = unknown>(payload: Record<string, unknown>): Promise<T>;

package/dist/app/lib/deliveries.js

@@ -0,0 +1,104 @@
+import { useCallback, useEffect, useState } from "react";
+import { ApiError } from "../../index.js";
+export function useDeliveries(activeId) {
+    const [rows, setRows] = useState(null);
+    const [detail, setDetail] = useState(null);
+    const [expiring, setExpiring] = useState(0);
+    const [settings, setSettings] = useState({ defaultHeroes: [] });
+    const [error, setError] = useState(null);
+    const [busy, setBusy] = useState(false);
+    const load = useCallback(async () => {
+        try {
+            const out = await getJson("/admin/api/deliveries");
+            setRows(out.deliveries);
+            setExpiring(out.expiring);
+            setSettings(out.settings || { defaultHeroes: [] });
+            setError(null);
+        }
+        catch (e) {
+            setError(errorMessage(e));
+        }
+    }, []);
+    /* Rileggere UN transfer senza toccare `detail`: serve al transfer appena nato dentro
+       l'editor, che non ha una rotta aperta e non può farsi rimontare — sotto ha un upload che
+       cammina, e un rimontaggio lo interromperebbe. */
+    const read = useCallback(async (id) => {
+        try {
+            const out = await getJson(`/admin/api/deliveries?id=${encodeURIComponent(id)}`);
+            return out.delivery;
+        }
+        catch {
+            return null;
+        }
+    }, []);
+    const open = useCallback(async (id) => {
+        setBusy(true);
+        try {
+            const out = await getJson(`/admin/api/deliveries?id=${encodeURIComponent(id)}`);
+            setDetail(out.delivery);
+            setError(null);
+        }
+        catch (e) {
+            setError(errorMessage(e));
+            setDetail(null);
+        }
+        finally {
+            setBusy(false);
+        }
+    }, []);
+    useEffect(() => { void load(); }, [load]);
+    useEffect(() => {
+        if (activeId)
+            void open(activeId);
+        else
+            setDetail(null);
+    }, [activeId, open]);
+    const action = useCallback(async (payload, options = {}) => {
+        setBusy(true);
+        try {
+            const out = await postJson("/admin/api/deliveries", payload);
+            setError(null);
+            if (options.reload !== false)
+                await load();
+            return out;
+        }
+        catch (e) {
+            if (options.reload !== false)
+                setError(errorMessage(e));
+            throw e;
+        }
+        finally {
+            setBusy(false);
+        }
+    }, [load]);
+    const refresh = useCallback(async () => {
+        await load();
+        if (activeId)
+            await open(activeId);
+    }, [activeId, load, open]);
+    return { rows, detail, expiring, settings, error, busy, load, open, read, action, refresh, setDetail };
+}
+/* Un'azione sui transfer senza passare dall'hook: la usa la coda dei caricamenti, che vive
+   fuori da React e deve poter chiudere un pacchetto anche mentre il pannello è altrove. */
+export async function deliveryAction(payload) {
+    return postJson("/admin/api/deliveries", payload);
+}
+async function getJson(url) {
+    return request(url);
+}
+async function postJson(url, body) {
+    return request(url, {
+        method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body),
+    });
+}
+async function request(url, init) {
+    const res = await fetch(url, { cache: "no-store", ...init });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok || body.ok === false) {
+        throw new ApiError(body.error || `HTTP ${res.status}`, body.code || "error", res.status);
+    }
+    return body;
+}
+function errorMessage(e) {
+    return e instanceof Error ? e.message : String(e);
+}

package/dist/app/lib/delivery-drop.d.ts

@@ -0,0 +1 @@
+export declare function filesFromDrop(data: DataTransfer): Promise<File[]>;

package/dist/app/lib/delivery-drop.js

@@ -0,0 +1,72 @@
+import { deliveryRelativeName, setDeliveryRelativePath } from "./delivery-upload";
+/* Mantiene le cartelle anche quando arrivano da drag & drop. Le API dei browser
+ * hanno due forme (File System Access e webkitEntry), quindi usiamo entrambe e
+ * ripieghiamo sulla FileList senza perdere i normali file trascinati. */
+export async function filesFromDrop(data) {
+    const collected = [];
+    /* getAsFileSystemHandle va invocata mentre il gesto drop è ancora attivo.
+       Acquisiamo quindi tutte le promise prima di attendere la prima cartella. */
+    const descriptors = [...data.items].filter((item) => item.kind === "file").map((item) => {
+        const modern = item.getAsFileSystemHandle;
+        const legacy = item.webkitGetAsEntry?.();
+        return { item, handle: modern ? modern.call(item) : null, legacy };
+    });
+    for (const descriptor of descriptors) {
+        const { item } = descriptor;
+        if (item.kind !== "file")
+            continue;
+        if (descriptor.handle) {
+            const handle = await descriptor.handle.catch(() => null);
+            if (handle) {
+                await walkHandle(handle, "", collected);
+                continue;
+            }
+        }
+        if (descriptor.legacy) {
+            await walkLegacy(descriptor.legacy, "", collected);
+            continue;
+        }
+        const file = item.getAsFile();
+        if (file)
+            collected.push(file);
+    }
+    if (!collected.length)
+        collected.push(...data.files);
+    const unique = new Map();
+    for (const file of collected) {
+        const path = deliveryRelativeName(file);
+        unique.set(`${path}\0${file.size}\0${file.lastModified}`, file);
+    }
+    return [...unique.values()];
+}
+async function walkHandle(handle, parent, out) {
+    const path = parent ? `${parent}/${handle.name}` : handle.name;
+    if (handle.kind === "file") {
+        const file = await handle.getFile();
+        setDeliveryRelativePath(file, path);
+        out.push(file);
+        return;
+    }
+    const directory = handle;
+    for await (const child of directory.values())
+        await walkHandle(child, path, out);
+}
+async function walkLegacy(entry, parent, out) {
+    const path = parent ? `${parent}/${entry.name}` : entry.name;
+    if (entry.isFile) {
+        const file = await new Promise((resolve, reject) => entry.file(resolve, reject));
+        setDeliveryRelativePath(file, path);
+        out.push(file);
+        return;
+    }
+    if (!entry.isDirectory)
+        return;
+    const reader = entry.createReader();
+    for (;;) {
+        const page = await new Promise((resolve, reject) => reader.readEntries(resolve, reject));
+        if (!page.length)
+            break;
+        for (const child of page)
+            await walkLegacy(child, path, out);
+    }
+}

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

@@ -0,0 +1,78 @@
+export interface DeliveryUploadProgress {
+    phase: "originals" | "derivatives" | "finalizing";
+    file: string;
+    doneFiles: number;
+    totalFiles: number;
+    sourceBytes: number;
+    uploadedBytes: number;
+    transferredBytes: number;
+    startedAt: number;
+    transferStartedAt?: number;
+    note?: string;
+}
+export interface DeliveryManifestEntry {
+    name: string;
+    type: string;
+    original: ZipMember;
+    web?: ZipMember;
+    thumb?: ZipMember;
+    width?: number;
+    height?: number;
+}
+export interface DeliveryManifest {
+    version: 1;
+    createdAt: string;
+    entries: DeliveryManifestEntry[];
+    skipped: {
+        name: string;
+        reason: string;
+    }[];
+}
+interface ZipMember {
+    offset: number;
+    length: number;
+    crc32: number;
+}
+interface UploadOptions {
+    galleryEnabled: boolean;
+    webEnabled: boolean;
+}
+interface UploadResult {
+    manifest: DeliveryManifest;
+    fileCount: number;
+    sourceBytes: number;
+    storedBytes: number;
+}
+export interface UploadControl {
+    gate(): Promise<void>;
+}
+export declare class UploadCancelled extends Error {
+    constructor();
+}
+export declare function uploadDeliveryPackage(deliveryId: string, packageId: string, selected: File[], options: UploadOptions, onProgress: (progress: DeliveryUploadProgress) => void, control?: UploadControl): Promise<UploadResult>;
+interface ZipSink {
+    write(data: Uint8Array): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class ZipStream {
+    private sink;
+    private offset;
+    private entries;
+    constructor(sink: ZipSink);
+    add(nameValue: string, blob: Blob, progress?: (read: number) => void, modified?: Date): Promise<ZipMember>;
+    close(): Promise<void>;
+    private push;
+}
+export declare function setDeliveryRelativePath(file: File, path: string): void;
+export declare function deliveryRelativeName(file: File): string;
+export declare function deliverySelectionName(files: File[]): string;
+export declare function uploadDeliveryHeroObject(deliveryId: string, packageId: string, file: File): Promise<{
+    type: "object";
+    id: string;
+    sourceName: string;
+    width: number;
+    height: number;
+    bytes: number;
+}>;
+export declare function deliverySourceFingerprint(files: File[]): Promise<string>;
+export {};