@cardinali-studio/adminkit 1.0.0

package/dist/api.d.ts

@@ -0,0 +1,195 @@
+export declare class ApiError extends Error {
+    code: string;
+    status: number;
+    constructor(message: string, code: string, status: number);
+}
+export interface AssetFile {
+    key: string;
+    name: string;
+    size: number;
+    url: string;
+    uploaded?: string;
+    capturedAt?: string;
+    type?: string;
+    w?: number | null;
+    h?: number | null;
+}
+export interface AssetFolder {
+    prefix: string;
+    name: string;
+    count?: number;
+    label?: string;
+}
+export interface TrashItem {
+    trashKey: string;
+    originalKey: string;
+    name: string;
+    deletedAt?: string;
+    size: number;
+    type?: string;
+    previewUrl: string;
+}
+export interface ContactRequestRow {
+    id: number;
+    name: string;
+    email: string;
+    message: string;
+    created_at: string;
+    handled_at: string | null;
+}
+/** Una pagina come arriva dall'elenco: identità, versione del file, e il modello. */
+export interface RepoPage {
+    slug: string;
+    url: string;
+    /** Lo `sha` del blob su GitHub: identifica la VERSIONE di questo file, non il suo contenuto. */
+    sha: string;
+    page: Record<string, unknown>;
+}
+export declare const api: {
+    pages: () => Promise<{
+        ok: true;
+        commit: string;
+        pages: RepoPage[];
+    }>;
+    pageBody: (slug: string) => Promise<{
+        ok: true;
+        slug: string;
+        body: string;
+        page: Record<string, unknown>;
+    }>;
+    savePages: (pages: unknown[]) => Promise<{
+        ok: true;
+        commit: string;
+        files: number;
+        skipped: string[];
+        shas?: Record<string, string>;
+    }>;
+    publishState: () => Promise<{
+        ok: true;
+        configured: boolean;
+        ahead: number;
+        behind: number;
+        error?: string;
+        commits: {
+            message: string;
+            date: string | null;
+        }[];
+    }>;
+    publish: () => Promise<{
+        ok: true;
+        published: boolean;
+        commit?: string;
+        message?: string;
+    }>;
+    assets: (prefix?: string, opts?: {
+        recursive?: boolean;
+    }) => Promise<{
+        ok: true;
+        prefix: string;
+        label?: string;
+        folders: AssetFolder[];
+        files: AssetFile[];
+    }>;
+    folders: () => Promise<{
+        ok: true;
+        folders: AssetFolder[];
+    }>;
+    /** `label` è il nome per esteso; lo slug della chiave lo calcola il server e lo restituisce. */
+    createFolder: (parent: string, name: string, opts?: {
+        label?: string;
+        relabel?: boolean;
+    }) => Promise<{
+        ok: true;
+        prefix: string;
+        exists?: boolean;
+        label?: string;
+    }>;
+    /** Con `skipRefs` copia senza cancellare gli originali e restituisce la mappa degli URL. */
+    move: (keys: string[], dest: string, opts?: {
+        skipRefs?: boolean;
+    }) => Promise<{
+        ok: true;
+        moved: number;
+        finalized?: number;
+        urlMap?: Record<string, string>;
+        pagesUpdated: string[];
+        failed: {
+            key: string;
+            error: string;
+        }[];
+        warning?: string;
+    }>;
+    /** Riscrive i riferimenti, poi elimina gli originali le cui copie sono state verificate. */
+    moveApplyRefs: (applyRefs: Record<string, string>) => Promise<{
+        ok: true;
+        moved: number;
+        finalized?: number;
+        pagesUpdated: string[];
+        failed: {
+            key: string;
+            error: string;
+        }[];
+        warning?: string;
+    }>;
+    usage: (target: {
+        keys?: string[];
+        prefixes?: string[];
+    }) => Promise<{
+        ok: true;
+        usage: Record<string, string[]>;
+        pages: string[];
+        count: number;
+        selectedCount: number;
+        blockers: {
+            path: string;
+            label: string;
+            reason: string;
+        }[];
+    }>;
+    remove: (target: {
+        keys?: string[];
+        prefixes?: string[];
+    }, opts?: {
+        refsOnly?: boolean;
+        skipRefs?: boolean;
+        refsToken?: string;
+    }) => Promise<{
+        ok: true;
+        trashed: number;
+        pagesUpdated: string[];
+        refsToken?: string;
+    }>;
+    requests: () => Promise<{
+        ok: true;
+        requests: ContactRequestRow[];
+    }>;
+    markRequest: (id: number, handled: boolean) => Promise<{
+        ok: true;
+    }>;
+    deleteRequest: (id: number) => Promise<{
+        ok: true;
+    }>;
+    /** L'upload NON è JSON: corpo grezzo e metadati negli header (vedi assets/upload.js). */
+    upload: (prefix: string, file: File) => Promise<AssetFile>;
+    trash: () => Promise<{
+        ok: true;
+        items: TrashItem[];
+    }>;
+    trashRestore: (trashKeys: string[]) => Promise<{
+        ok: true;
+        restored: string[];
+        conflicts: {
+            originalKey: string;
+            restoredAs: string;
+        }[];
+    }>;
+    trashDelete: (trashKeys: string[]) => Promise<{
+        ok: true;
+        removed: number;
+    }>;
+    trashEmpty: () => Promise<{
+        ok: true;
+        removed: number;
+    }>;
+};
+export declare function uploadQueue(prefix: string, files: File[], onProgress: (done: number, total: number, last?: AssetFile, error?: string) => void, concurrency?: number): Promise<AssetFile[]>;

package/dist/api.js

@@ -0,0 +1,118 @@
+/* Client tipizzato degli endpoint dell'admin. Un posto solo per sapere che forma hanno le
+ * risposte — e, soprattutto, per riconoscere i codici che il server ora sa distinguere:
+ * `unauthenticated` (sessione scaduta), `conflict` (qualcuno ha salvato nel frattempo),
+ * `unreadable` (un file che non sappiamo riprodurre). Prima qualunque errore diventava
+ * "backend non collegato", che manda a cercare il guasto dalla parte sbagliata. */
+export class ApiError extends Error {
+    code;
+    status;
+    constructor(message, code, status) {
+        super(message);
+        this.name = "ApiError";
+        this.code = code;
+        this.status = status;
+    }
+}
+async function call(url, init) {
+    const res = await fetch(url, { cache: "no-store", ...init });
+    let body = null;
+    try {
+        body = await res.json();
+    }
+    catch { /* risposta non JSON */ }
+    if (!res.ok || (body && body.ok === false)) {
+        const code = body?.code ?? (res.status === 401 ? "unauthenticated" : "error");
+        throw new ApiError(body?.error ?? `HTTP ${res.status}`, code, res.status);
+    }
+    return body;
+}
+const post = (url, data) => call(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(data),
+});
+export const api = {
+    // ---- pagine
+    /* L'elenco viene DAL REPO, non da `/index.json`, che è il sito pubblicato e quindi indietro
+     * di una build. `sha` è quello del file su GitHub e torna indietro nel salvataggio: è il modo
+     * di accorgersi che qualcun altro ha toccato la stessa pagina nel frattempo. */
+    pages: () => call("/admin/api/pages"),
+    /* Il corpo markdown, che nell'elenco non c'è: sono testi lunghi e servono solo alla pagina
+     * che si sta aprendo. `page` è il modello letto dallo stesso file. */
+    pageBody: (slug) => call(`/admin/api/pages/get?slug=${encodeURIComponent(slug)}`),
+    /* `shas` è la versione di ogni file DOPO il commit: senza, il salvataggio successivo
+     * partirebbe da una versione che non esiste più e verrebbe rifiutato. */
+    savePages: (pages) => post("/admin/api/pages", { pages }),
+    // ---- pubblicazione
+    /* Salvare scrive sulla bozza e non fa partire nessuna build; è questo che manda online. Due
+     * gesti separati, quindi due chiamate: una chiede quanto c'è di non pubblicato, l'altra lo
+     * pubblica. */
+    publishState: () => call("/admin/api/publish"),
+    publish: () => post("/admin/api/publish", {}),
+    // ---- media
+    /* `recursive` scende a qualunque profondità e restituisce solo chiave e nome dei file: serve
+     * a spostare o cancellare una cartella intera senza lasciare indietro ciò che sta annidato. */
+    assets: (prefix = "", opts = {}) => call(`/admin/api/assets?prefix=${encodeURIComponent(prefix)}${opts.recursive ? "&recursive=1" : ""}`),
+    folders: () => call("/admin/api/assets/folders"),
+    /** `label` è il nome per esteso; lo slug della chiave lo calcola il server e lo restituisce. */
+    createFolder: (parent, name, opts = {}) => post("/admin/api/assets/folder", { parent, name, ...opts }),
+    /** Con `skipRefs` copia senza cancellare gli originali e restituisce la mappa degli URL. */
+    move: (keys, dest, opts = {}) => post("/admin/api/assets/move", { keys, dest, ...opts }),
+    /** Riscrive i riferimenti, poi elimina gli originali le cui copie sono state verificate. */
+    moveApplyRefs: (applyRefs) => post("/admin/api/assets/move", { applyRefs }),
+    usage: (target) => post("/admin/api/assets/usage", target),
+    /* `refsOnly` pulisce solo i riferimenti nelle pagine (un commit, niente file spostati);
+     * `skipRefs` sposta i file e non tocca il repo. Servono a spezzare una cancellazione grande
+     * in più richieste senza fare un commit — cioè una build — per ogni gruppo. */
+    remove: (target, opts = {}) => post("/admin/api/assets/delete", { ...target, ...opts }),
+    // ---- richieste dal form di contatto
+    requests: () => call("/admin/api/requests"),
+    markRequest: (id, handled) => call("/admin/api/requests", {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ id, handled }),
+    }),
+    deleteRequest: (id) => call("/admin/api/requests", {
+        method: "DELETE",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ id }),
+    }),
+    /** L'upload NON è JSON: corpo grezzo e metadati negli header (vedi assets/upload.js). */
+    upload: (prefix, file) => call("/admin/api/assets/upload", {
+        method: "POST",
+        headers: {
+            "Content-Type": file.type || "application/octet-stream",
+            "X-Prefix": prefix,
+            "X-Filename": encodeURIComponent(file.name),
+        },
+        body: file,
+    }),
+    // ---- cestino
+    trash: () => call("/admin/api/assets/trash"),
+    trashRestore: (trashKeys) => post("/admin/api/assets/trash/restore", { trashKeys }),
+    trashDelete: (trashKeys) => post("/admin/api/assets/trash/delete", { trashKeys }),
+    trashEmpty: () => post("/admin/api/assets/trash/empty", {}),
+};
+/* Coda di upload a concorrenza limitata. Il vecchio admin caricava un file alla volta
+ * (app.js:922), il che su quaranta foto è tedioso senza motivo; tutte insieme invece saturano
+ * la connessione e rendono il progresso illeggibile. Tre è il compromesso.
+ * Un file che fallisce non ferma gli altri: si segnala e si prosegue. */
+export async function uploadQueue(prefix, files, onProgress, concurrency = 3) {
+    const out = [];
+    let done = 0, next = 0;
+    const worker = async () => {
+        while (next < files.length) {
+            const file = files[next++];
+            try {
+                const r = await api.upload(prefix, file);
+                out.push(r);
+                onProgress(++done, files.length, r);
+            }
+            catch (e) {
+                onProgress(++done, files.length, undefined, `${file.name}: ${e.message}`);
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, files.length) }, worker));
+    return out;
+}

package/dist/app/App.d.ts

@@ -0,0 +1,3 @@
+import "../theme.css";
+import "./app.css";
+export declare function App(): import("react").JSX.Element;