@cardinali-studio/adminkit 2.2.11 → 2.2.13

package/dist/form/media/media-move.js

@@ -0,0 +1,92 @@
+export function mediaMoveNeedsConfirmation(plan, multiFileThreshold = 2) {
+    return plan.folders.length > 0 || plan.directFiles.length >= multiFileThreshold;
+}
+export function mediaMoveConfirmation(plan, destinationLabel) {
+    const selectedParts = [
+        plan.directFiles.length
+            ? `${plan.directFiles.length} file ${plan.directFiles.length === 1 ? "selezionato direttamente" : "selezionati direttamente"}`
+            : "",
+        plan.folders.length ? `${plan.folders.length} ${plan.folders.length === 1 ? "cartella" : "cartelle"}` : "",
+    ].filter(Boolean).join(" e ");
+    return `Stai per spostare ${selectedParts} in ${destinationLabel}.\n\n`
+        + `File complessivi coinvolti, inclusi i discendenti: ${plan.totalFiles}.\n\n`
+        + "Gli indirizzi pubblici cambieranno e i riferimenti gestiti verranno aggiornati. Continuare?";
+}
+/**
+ * Esegue un piano già validato. Al primo errore non avvia altri gruppi né applica i riferimenti;
+ * le copie riuscite restano duplicati sicuri e gli originali restano disponibili.
+ */
+export async function executeMediaMovePlan(plan, destination, executor, onProgress, chunkSize = 10) {
+    for (const folder of plan.folders) {
+        const created = await executor.createFolder(destination, folder.name, { label: folder.name });
+        if (created.exists || created.prefix !== folder.target) {
+            throw new Error(`La destinazione della cartella «${folder.name}» non è più disponibile.`);
+        }
+        for (const sub of [...folder.folders].sort((a, b) => a.prefix.length - b.prefix.length)) {
+            const rel = sub.prefix.slice(folder.source.length);
+            const subName = rel.replace(/\/$/, "").split("/").pop();
+            await executor.createFolder(folder.target + rel.replace(/[^/]+\/$/, ""), sub.label || subName, {
+                label: sub.label || subName,
+            });
+        }
+    }
+    const transfers = [];
+    for (const folder of plan.folders) {
+        const byDir = new Map();
+        for (const file of folder.files) {
+            const rel = file.key.slice(folder.source.length);
+            const cut = rel.lastIndexOf("/");
+            const dir = cut >= 0 ? rel.slice(0, cut + 1) : "";
+            const keys = byDir.get(dir) ?? [];
+            keys.push(file.key);
+            byDir.set(dir, keys);
+        }
+        for (const [dir, keys] of byDir)
+            transfers.push({ keys, destination: folder.target + dir });
+    }
+    if (plan.directFiles.length)
+        transfers.push({ keys: plan.directFiles, destination });
+    let done = 0;
+    const urlMap = {};
+    onProgress(done, plan.totalFiles);
+    for (const transfer of transfers) {
+        for (let i = 0; i < transfer.keys.length; i += chunkSize) {
+            const group = transfer.keys.slice(i, i + chunkSize);
+            let result;
+            try {
+                result = await executor.move(group, transfer.destination);
+            }
+            catch (error) {
+                const notStarted = Math.max(0, plan.totalFiles - done - group.length);
+                throw new Error(`Spostamento interrotto: ${done} file copiati, ${group.length} con esito non confermato, ${notStarted} non iniziati. `
+                    + `Gli originali sono stati conservati. Dettaglio: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            Object.assign(urlMap, result.urlMap ?? {});
+            done += result.moved ?? 0;
+            onProgress(done, plan.totalFiles);
+            if (result.failed?.length || (result.moved ?? 0) !== group.length) {
+                const failed = result.failed?.length ?? group.length - (result.moved ?? 0);
+                const notStarted = Math.max(0, plan.totalFiles - done - failed);
+                throw new Error(`Spostamento interrotto: ${done} file copiati, ${failed} falliti, ${notStarted} non iniziati. `
+                    + "Gli originali sono stati conservati; le copie già create possono restare come duplicati.");
+            }
+        }
+    }
+    if (Object.keys(urlMap).length) {
+        let applied;
+        try {
+            applied = await executor.applyReferences(urlMap);
+        }
+        catch (error) {
+            throw new Error(`Tutte le ${done} copie sono state create, ma i riferimenti non sono stati applicati. `
+                + `Gli originali sono stati conservati e le copie possono restare come duplicati. Dettaglio: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (applied.failed?.length) {
+            throw new Error(`Spostamento applicato con ${applied.failed.length} originali rimasti come duplicati.`);
+        }
+    }
+    if (plan.folders.length) {
+        await executor.removeSourceFolders(plan.folders.map((folder) => folder.source));
+    }
+    return { completed: done, total: plan.totalFiles };
+}

package/dist/form/media/media-upload-queue.d.ts

@@ -0,0 +1,31 @@
+export type MediaUploadState = "running" | "done" | "failed";
+export interface MediaUploadJob {
+    id: string;
+    title: string;
+    prefix: string;
+    state: MediaUploadState;
+    total: number;
+    conversionDone: number;
+    uploadDone: number;
+    converted: number;
+    originals: number;
+    failed: number;
+    autoWebp: boolean;
+    errors: string[];
+}
+interface StartInput {
+    prefix: string;
+    title: string;
+    files: File[];
+    autoWebp: boolean;
+}
+export declare function useMediaUploads(): MediaUploadJob[];
+export declare function useMediaUploadCompletions(): number;
+/** Snapshot non mutabile per diagnostica e test della coda fuori da React. */
+export declare function mediaUploadsSnapshot(): MediaUploadJob[];
+export declare function dismissMediaUpload(id: string): void;
+/** Accoda e torna subito: la finestra di scelta può chiudersi, il lavoro resta nel dock. */
+export declare function startMediaUpload(input: StartInput): string;
+export declare function adaptiveConversionConcurrency(files: File[], enabled?: boolean): number;
+export declare function adaptiveUploadConcurrency(): number;
+export {};

package/dist/form/media/media-upload-queue.js

@@ -0,0 +1,230 @@
+/* Upload persistenti della libreria Media.
+ *
+ * Come per i transfer, lo stato vive fuori da React: cambiare rotta nell'admin non smonta la
+ * conversione, non perde l'avanzamento e non nasconde gli errori. Le due fasi hanno pool
+ * distinti e una coda limitata fra loro: conversione e rete si sovrappongono, ma non si
+ * accumulano in RAM decine di WebP già pronti.
+ */
+import { useSyncExternalStore } from "react";
+import { api, ApiError } from "../../api.js";
+import { convertMediaImage, isConvertibleImage, jpegCapturedAt } from "./image-conversion.js";
+let jobs = [];
+let completions = 0;
+const listeners = new Set();
+function emit() {
+    jobs = [...jobs];
+    for (const listener of listeners)
+        listener();
+}
+function patch(id, change) {
+    jobs = jobs.map((job) => job.id === id ? { ...job, ...change } : job);
+    emit();
+}
+function current(id) {
+    return jobs.find((job) => job.id === id);
+}
+function subscribe(listener) {
+    listeners.add(listener);
+    return () => { listeners.delete(listener); };
+}
+export function useMediaUploads() {
+    return useSyncExternalStore(subscribe, () => jobs, () => jobs);
+}
+export function useMediaUploadCompletions() {
+    return useSyncExternalStore(subscribe, () => completions, () => completions);
+}
+/** Snapshot non mutabile per diagnostica e test della coda fuori da React. */
+export function mediaUploadsSnapshot() { return jobs; }
+export function dismissMediaUpload(id) {
+    jobs = jobs.filter((job) => job.id !== id || job.state === "running");
+    emit();
+}
+/** Accoda e torna subito: la finestra di scelta può chiudersi, il lavoro resta nel dock. */
+export function startMediaUpload(input) {
+    const id = crypto.randomUUID();
+    jobs = [...jobs, {
+            id, title: input.title, prefix: input.prefix, state: "running", total: input.files.length,
+            conversionDone: 0, uploadDone: 0, converted: 0, originals: 0, failed: 0,
+            autoWebp: input.autoWebp, errors: [],
+        }];
+    emit();
+    void run(id, input);
+    return id;
+}
+async function run(id, input) {
+    const conversionWorkers = adaptiveConversionConcurrency(input.files, input.autoWebp);
+    const uploadWorkers = adaptiveUploadConcurrency();
+    /* Due soli elementi pronti: abbastanza per non lasciare la rete in attesa, pochi abbastanza
+     * da non tenere in memoria un intero servizio fotografico già convertito. */
+    const ready = new BoundedQueue(2);
+    let next = 0;
+    const convert = async () => {
+        while (next < input.files.length) {
+            const file = input.files[next++];
+            const prepared = await prepare(file, input.autoWebp);
+            const job = current(id);
+            patch(id, {
+                conversionDone: job.conversionDone + 1,
+                converted: job.converted + (prepared.converted ? 1 : 0),
+                originals: job.originals + (prepared.originalFallback ? 1 : 0),
+                errors: prepared.conversionError
+                    ? appendError(job.errors, `${file.name}: conversione non riuscita, carico l’originale (${prepared.conversionError})`)
+                    : job.errors,
+            });
+            await ready.push(prepared);
+        }
+    };
+    const upload = async () => {
+        for (;;) {
+            const prepared = await ready.shift();
+            if (!prepared)
+                return;
+            try {
+                await uploadWithRetry(input.prefix, prepared.upload, prepared.capturedAt);
+                const job = current(id);
+                patch(id, { uploadDone: job.uploadDone + 1 });
+            }
+            catch (error) {
+                const job = current(id);
+                patch(id, {
+                    uploadDone: job.uploadDone + 1,
+                    failed: job.failed + 1,
+                    errors: appendError(job.errors, `${prepared.source.name}: ${readable(error)}`),
+                });
+            }
+        }
+    };
+    try {
+        const consumers = Array.from({ length: Math.min(uploadWorkers, input.files.length) }, upload);
+        await Promise.all(Array.from({ length: Math.min(conversionWorkers, input.files.length) }, convert));
+        ready.close();
+        await Promise.all(consumers);
+        patch(id, { state: current(id).failed ? "failed" : "done" });
+    }
+    catch (error) {
+        /* Un errore della coda è un guasto nostro, non di una foto. Chiude comunque i consumer e
+           resta visibile: un job "in corso" per sempre sarebbe impossibile da diagnosticare. */
+        ready.close();
+        const job = current(id);
+        patch(id, { state: "failed", failed: Math.max(1, job.failed), errors: appendError(job.errors, readable(error)) });
+    }
+    finally {
+        completions += 1;
+        emit();
+    }
+}
+async function prepare(file, autoWebp) {
+    const capturedAt = await jpegCapturedAt(file);
+    if (!autoWebp || !isConvertibleImage(file)) {
+        return { source: file, upload: file, converted: false, originalFallback: false, capturedAt };
+    }
+    let last;
+    /* Tre tentativi reali. Fra uno e l'altro restituiamo il controllo al browser: dopo una
+     * pressione di memoria può liberare bitmap/canvas chiusi prima di riprovare. */
+    for (let attempt = 1; attempt <= 3; attempt++) {
+        try {
+            const converted = await convertMediaImage(file);
+            return { source: file, upload: converted, converted: true, originalFallback: false, capturedAt };
+        }
+        catch (error) {
+            last = error;
+            if (attempt < 3)
+                await delay(attempt * 180);
+        }
+    }
+    return {
+        source: file, upload: file, converted: false, originalFallback: true,
+        conversionError: readable(last), capturedAt,
+    };
+}
+async function uploadWithRetry(prefix, file, capturedAt) {
+    let last;
+    for (let attempt = 1; attempt <= 3; attempt++) {
+        try {
+            return await api.upload(prefix, file, { capturedAt });
+        }
+        catch (error) {
+            last = error;
+            if (attempt === 3 || !retryable(error))
+                throw error;
+            await delay(attempt * 300);
+        }
+    }
+    throw last;
+}
+function retryable(error) {
+    return !(error instanceof ApiError) || error.status === 408 || error.status === 429 || error.status >= 500;
+}
+export function adaptiveConversionConcurrency(files, enabled = true) {
+    if (!enabled || !files.some(isConvertibleImage))
+        return Math.min(4, Math.max(1, files.length));
+    const cores = typeof navigator === "undefined" ? 4 : navigator.hardwareConcurrency || 4;
+    const memory = typeof navigator === "undefined"
+        ? 4
+        : navigator.deviceMemory || 4;
+    let count = cores >= 12 && memory >= 8 ? 3 : cores >= 6 && memory >= 4 ? 2 : 1;
+    /* Il decoder HEIC ha un buffer compresso, un RGBA completo e il canvas di uscita. Due in
+     * parallelo sono già una quantità importante di memoria anche su una workstation. */
+    if (files.some((file) => /\.(?:heic|heif)$/i.test(file.name)))
+        count = Math.min(count, 2);
+    if (files.some((file) => file.size >= 30 * 1024 * 1024))
+        count = 1;
+    return Math.min(count, Math.max(1, files.length));
+}
+export function adaptiveUploadConcurrency() {
+    if (typeof navigator === "undefined")
+        return 3;
+    const connection = navigator.connection;
+    if (connection?.saveData || connection?.effectiveType === "slow-2g" || connection?.effectiveType === "2g")
+        return 2;
+    const memory = navigator.deviceMemory || 4;
+    return (navigator.hardwareConcurrency || 4) >= 8 && memory >= 8 ? 4 : 3;
+}
+function appendError(errors, next) {
+    /* Nel dock servono esempi utili, non duecento righe. Il conteggio completo resta in `failed`
+       e `originals`; le prime otto dicono quali file guardare. */
+    return errors.length >= 8 ? errors : [...errors, next];
+}
+function readable(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function delay(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
+class BoundedQueue {
+    capacity;
+    values = [];
+    readers = [];
+    writers = [];
+    closed = false;
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    async push(value) {
+        while (!this.closed && this.values.length >= this.capacity && this.readers.length === 0) {
+            await new Promise((resolve) => this.writers.push(resolve));
+        }
+        if (this.closed)
+            throw new Error("coda Media chiusa");
+        const reader = this.readers.shift();
+        if (reader)
+            reader(value);
+        else
+            this.values.push(value);
+    }
+    async shift() {
+        const value = this.values.shift();
+        if (value) {
+            this.writers.shift()?.();
+            return value;
+        }
+        if (this.closed)
+            return null;
+        return new Promise((resolve) => this.readers.push(resolve));
+    }
+    close() {
+        this.closed = true;
+        for (const reader of this.readers.splice(0))
+            reader(null);
+        for (const writer of this.writers.splice(0))
+            writer();
+    }
+}

package/dist/form/media/useMediaLibrary.d.ts

@@ -1,5 +1,6 @@
 import { type AssetFile, type AssetFolder } from "../../api.js";
 import type { MediaOperationStatus } from "../../media.js";
+export type MediaOperationState = "idle" | "planning" | "awaiting_confirmation" | "moving" | "deleting" | "renaming" | "creating_folder" | "journal";
 export type SortKey = "uploaded" | "capturedAt" | "name" | "size";
 export declare const SORT_LABELS: Record<SortKey, string>;
 export interface MediaLibrary {
@@ -10,7 +11,14 @@ export interface MediaLibrary {
     subfolders: AssetFolder[];
     shown: AssetFile[];
     selected: Set<string>;
+    selectableIds: string[];
+    selectedFiles: string[];
+    selectedFolders: string[];
+    allSelected: boolean;
+    someSelected: boolean;
     busy: boolean;
+    mutating: boolean;
+    operationState: MediaOperationState;
     error: string | null;
     mediaOperations: MediaOperationStatus[];
     /** Avanzamento di un'operazione lunga. `verb` è quello che si sta facendo ("Carico",
@@ -25,6 +33,8 @@ export interface MediaLibrary {
     sortDir: "asc" | "desc";
     uploadOpen: boolean;
     viewing: number | null;
+    autoWebp: boolean;
+    settingsBusy: boolean;
     go(prefix: string): void;
     reload(): void;
     toggle(key: string): void;
@@ -34,10 +44,12 @@ export interface MediaLibrary {
     /** Vero se sono passati tutti: chi ha aperto un dialogo lo chiude solo in quel caso. */
     upload(files: File[] | FileList): Promise<boolean>;
     setUploadOpen(open: boolean): void;
+    setAutoWebp(on: boolean): Promise<void>;
     view(i: number | null): void;
     step(delta: number): void;
     /** File e cartelle insieme: una cartella si riconosce dalla chiave, che finisce con "/". */
     move(ids: string[], dest: string): Promise<void>;
+    canMoveTo(ids: string[], dest: string): boolean;
     remove(ids: string[]): Promise<void>;
     /** `parent` esplicito: chi preme il pulsante sa dove sta creando, il pulsante non lo indovina. */
     newFolder(parent: string): Promise<void>;