@cardinali-studio/adminkit 1.0.0

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

@@ -0,0 +1,585 @@
+/* Motore browser della consegna.
+ *
+ * - ZIP STORE/ZIP64: le fotografie sono già compresse, ricomprimerle spreca CPU.
+ * - memoria limitata: file a slice da 4 MiB, parti B2 da 16 MiB, una foto derivata alla volta.
+ * - upload diretto a B2 tramite URL PUT prefirmati; i byte non passano dalla Function.
+ * - il manifest conserva gli offset dei membri STORE, così la Function pubblica può
+ *   servire una singola foto con un GET Range senza duplicarla come oggetto.
+ */
+const PART = 16 * 1024 * 1024;
+const READ = 4 * 1024 * 1024;
+const UPLOAD_CONCURRENCY = 4;
+const IMAGE = /\.(jpe?g|png|webp)$/i;
+const enc = new TextEncoder();
+const droppedPaths = new WeakMap();
+export class UploadCancelled extends Error {
+    constructor() { super("Caricamento annullato"); this.name = "UploadCancelled"; }
+}
+export async function uploadDeliveryPackage(deliveryId, packageId, selected, options, onProgress, control) {
+    const startedAt = Date.now();
+    const files = [...selected].sort((a, b) => deliveryRelativeName(a).localeCompare(deliveryRelativeName(b), undefined, { numeric: true, sensitivity: "base" }));
+    if (!files.length)
+        throw new Error("Nessun file selezionato");
+    const sourceBytes = files.reduce((n, f) => n + f.size, 0);
+    const entries = [];
+    let processed = 0;
+    let currentOriginal = "";
+    const originalsSink = new B2Sink(deliveryId, packageId, "originals", reportOriginals, control);
+    const originals = new ZipStream(originalsSink);
+    function reportOriginals() {
+        onProgress({
+            phase: "originals", file: currentOriginal, doneFiles: processed, totalFiles: files.length,
+            sourceBytes, uploadedBytes: originalsSink.uploadedBytes,
+            transferredBytes: originalsSink.transferredBytes, startedAt,
+            transferStartedAt: originalsSink.transferStartedAt || undefined,
+        });
+    }
+    for (const file of files) {
+        if (control)
+            await control.gate();
+        const name = safePath(deliveryRelativeName(file));
+        currentOriginal = name;
+        const member = await originals.add(name, file, reportOriginals, new Date(file.lastModified));
+        entries.push({ name, type: file.type || mimeFromName(name), original: member });
+        processed++;
+        reportOriginals();
+    }
+    await originals.close();
+    const wantWebArchive = options.webEnabled || options.galleryEnabled;
+    let webSink = null;
+    let thumbsSink = null;
+    let webZip = null;
+    let thumbsZip = null;
+    const skipped = [];
+    if (wantWebArchive) {
+        webSink = new B2Sink(deliveryId, packageId, "web", undefined, control);
+        webZip = new ZipStream(webSink);
+    }
+    if (options.galleryEnabled) {
+        thumbsSink = new B2Sink(deliveryId, packageId, "thumbs", undefined, control);
+        thumbsZip = new ZipStream(thumbsSink);
+    }
+    if (webZip) {
+        let imageDone = 0;
+        const imageFiles = files.filter((f) => IMAGE.test(f.name));
+        for (const file of imageFiles) {
+            if (control)
+                await control.gate();
+            const sourceName = safePath(deliveryRelativeName(file));
+            try {
+                const variants = await makeVariants(file, !!thumbsZip);
+                const outputName = sourceName.replace(/\.[^.\/]+$/, "") + ".webp";
+                const modified = new Date(file.lastModified);
+                const web = await webZip.add(outputName, variants.display, undefined, modified);
+                const entry = entries.find((it) => it.name === sourceName);
+                if (entry) {
+                    entry.web = web;
+                    entry.width = variants.width;
+                    entry.height = variants.height;
+                    if (thumbsZip && variants.thumb) {
+                        entry.thumb = await thumbsZip.add(outputName, variants.thumb, undefined, modified);
+                    }
+                }
+            }
+            catch (e) {
+                skipped.push({ name: sourceName, reason: e instanceof Error ? e.message : String(e) });
+            }
+            imageDone++;
+            onProgress({
+                phase: "derivatives", file: sourceName, doneFiles: imageDone,
+                totalFiles: imageFiles.length, sourceBytes,
+                uploadedBytes: originalsSink.uploadedBytes + (webSink?.uploadedBytes || 0) +
+                    (thumbsSink?.uploadedBytes || 0),
+                transferredBytes: originalsSink.transferredBytes + (webSink?.transferredBytes || 0) +
+                    (thumbsSink?.transferredBytes || 0),
+                startedAt,
+                transferStartedAt: firstStartedAt(originalsSink, webSink, thumbsSink),
+                note: skipped.length ? `${skipped.length} senza anteprima` : undefined,
+            });
+        }
+        await webZip.close();
+        if (thumbsZip)
+            await thumbsZip.close();
+    }
+    onProgress({
+        phase: "finalizing", file: "", doneFiles: files.length, totalFiles: files.length,
+        sourceBytes, uploadedBytes: originalsSink.uploadedBytes + (webSink?.uploadedBytes || 0) +
+            (thumbsSink?.uploadedBytes || 0),
+        transferredBytes: originalsSink.transferredBytes + (webSink?.transferredBytes || 0) +
+            (thumbsSink?.transferredBytes || 0),
+        startedAt,
+        transferStartedAt: firstStartedAt(originalsSink, webSink, thumbsSink),
+    });
+    return {
+        manifest: { version: 1, createdAt: new Date().toISOString(), entries, skipped },
+        fileCount: files.length,
+        sourceBytes,
+        storedBytes: originalsSink.totalBytes + (webSink?.totalBytes || 0) + (thumbsSink?.totalBytes || 0),
+    };
+}
+class B2Sink {
+    deliveryId;
+    packageId;
+    variant;
+    uploadedBytes = 0;
+    transferredBytes = 0;
+    transferStartedAt = 0;
+    totalBytes = 0;
+    chunks = [];
+    buffered = 0;
+    session = null;
+    partNumber = 0;
+    priorParts = new Map();
+    inFlight = new Set();
+    failure = null;
+    onTransfer;
+    control;
+    constructor(deliveryId, packageId, variant, onTransfer, control) {
+        this.deliveryId = deliveryId;
+        this.packageId = packageId;
+        this.variant = variant;
+        this.onTransfer = onTransfer;
+        this.control = control;
+    }
+    async write(input) {
+        if (!input.byteLength)
+            return;
+        this.chunks.push(input);
+        this.buffered += input.byteLength;
+        this.totalBytes += input.byteLength;
+        while (this.buffered >= PART)
+            await this.queuePart(this.take(PART));
+    }
+    async close() {
+        if (this.session?.state === "completed") {
+            const rest = this.take(this.buffered);
+            this.markUploaded(rest.byteLength, false);
+            await this.drain();
+            return;
+        }
+        if (!this.session) {
+            const body = this.take(this.buffered);
+            const signed = await postJson({
+                action: "putPresign", id: this.deliveryId, packageId: this.packageId, variant: this.variant,
+            });
+            this.startTransfer();
+            const res = await fetch(signed.url, {
+                method: "PUT", body: body.buffer, headers: { "Content-Type": "application/zip" },
+            });
+            if (!res.ok)
+                throw new Error(`Caricamento non riuscito (${res.status}). Riprova fra poco.`);
+            await postJson({
+                action: "putComplete", id: this.deliveryId, packageId: this.packageId,
+                variant: this.variant, bytes: body.byteLength,
+            });
+            this.markUploaded(body.byteLength, true);
+            return;
+        }
+        if (this.buffered)
+            await this.queuePart(this.take(this.buffered));
+        await this.drain();
+        await postJson({ action: "complete", uploadId: this.session.id });
+    }
+    async ensureSession() {
+        if (this.session)
+            return this.session;
+        const out = await postJson({
+            action: "create", id: this.deliveryId, packageId: this.packageId, variant: this.variant,
+        });
+        this.session = out.upload;
+        if (out.upload.state === "completed")
+            return out.upload;
+        const reconciled = await postJson({
+            action: "reconcile", uploadId: out.upload.id,
+        });
+        this.priorParts = new Map(reconciled.parts.map((part) => [part.partNumber, part]));
+        return out.upload;
+    }
+    async queuePart(body) {
+        /* Qui passa OGNI parte: è il punto in cui pausa e annullamento arrivano davvero, anche
+           dentro un file solo da venti giga. */
+        if (this.control)
+            await this.control.gate();
+        const session = await this.ensureSession();
+        const partNumber = ++this.partNumber;
+        await this.failIfNeeded();
+        let task;
+        task = this.uploadPart(body, partNumber, session)
+            .catch((error) => {
+            if (this.failure == null)
+                this.failure = error;
+        })
+            .finally(() => this.inFlight.delete(task));
+        this.inFlight.add(task);
+        if (this.inFlight.size >= UPLOAD_CONCURRENCY) {
+            await Promise.race(this.inFlight);
+            await this.failIfNeeded();
+        }
+    }
+    async uploadPart(body, partNumber, session) {
+        if (session.state === "completed") {
+            this.markUploaded(body.byteLength, false);
+            return;
+        }
+        const digest = await digestHex(body);
+        const prior = this.priorParts.get(partNumber);
+        if (prior?.size === body.byteLength && prior.digest === digest) {
+            this.markUploaded(body.byteLength, false);
+            return;
+        }
+        const signed = await postJson({
+            action: "presign", uploadId: session.id, partNumber,
+        });
+        let res = null;
+        let failure = "errore di rete o CORS";
+        for (let attempt = 0; attempt < 3; attempt++) {
+            this.startTransfer();
+            res = await fetch(signed.url, {
+                method: "PUT", body: body.buffer, headers: { "Content-Type": "application/octet-stream" },
+            }).catch(() => null);
+            if (res?.ok)
+                break;
+            if (res) {
+                const detail = (await res.text().catch(() => "")).replace(/\s+/g, " ").slice(0, 180);
+                failure = `HTTP ${res.status}${detail ? ` · ${detail}` : ""}`;
+            }
+            await delay(500 * 2 ** attempt);
+        }
+        if (!res?.ok) {
+            throw new Error(`Un pezzo del caricamento non è passato (${failure}). Riprova.`);
+        }
+        const etag = res.headers.get("etag");
+        if (!etag) {
+            throw new Error("L’archivio non espone l’header ETag: manca la configurazione CORS del bucket (vedi DELIVERY.md)");
+        }
+        let recorded = false;
+        for (let attempt = 0; attempt < 3 && !recorded; attempt++) {
+            try {
+                await postJson({
+                    action: "record", uploadId: session.id, partNumber, etag,
+                    digest, size: body.byteLength,
+                });
+                recorded = true;
+            }
+            catch {
+                if (attempt === 2)
+                    throw new Error("Un pezzo del caricamento non è stato registrato. Riprova.");
+                await delay(400 * 2 ** attempt);
+            }
+        }
+        this.markUploaded(body.byteLength, true);
+    }
+    async drain() {
+        await Promise.all([...this.inFlight]);
+        await this.failIfNeeded();
+    }
+    async failIfNeeded() {
+        if (this.failure == null)
+            return;
+        await Promise.all([...this.inFlight]);
+        const error = this.failure;
+        this.failure = null;
+        throw error;
+    }
+    startTransfer() {
+        if (!this.transferStartedAt)
+            this.transferStartedAt = Date.now();
+    }
+    markUploaded(size, transferred) {
+        this.uploadedBytes += size;
+        if (transferred)
+            this.transferredBytes += size;
+        this.onTransfer?.();
+    }
+    take(size) {
+        const out = new Uint8Array(size);
+        let offset = 0;
+        while (offset < size) {
+            const first = this.chunks[0];
+            if (!first)
+                throw new Error("buffer ZIP incoerente");
+            const count = Math.min(first.byteLength, size - offset);
+            out.set(first.subarray(0, count), offset);
+            offset += count;
+            if (count === first.byteLength)
+                this.chunks.shift();
+            else
+                this.chunks[0] = first.subarray(count);
+        }
+        this.buffered -= size;
+        return out;
+    }
+}
+function firstStartedAt(...sinks) {
+    const values = sinks.map((sink) => sink?.transferStartedAt || 0).filter(Boolean);
+    return values.length ? Math.min(...values) : undefined;
+}
+export class ZipStream {
+    sink;
+    offset = 0;
+    entries = [];
+    constructor(sink) { this.sink = sink; }
+    async add(nameValue, blob, progress, modified = new Date()) {
+        const name = enc.encode(safePath(nameValue));
+        const size = blob.size;
+        const localOffset = this.offset;
+        const zip64 = size >= 0xffffffff;
+        const extra = zip64 ? zip64Extra([size, size]) : new Uint8Array();
+        const local = bytes(30 + name.length + extra.length);
+        const v = view(local);
+        v.setUint32(0, 0x04034b50, true);
+        v.setUint16(4, zip64 ? 45 : 20, true);
+        v.setUint16(6, 0x0808, true); // descriptor + nomi UTF-8
+        v.setUint16(8, 0, true); // STORE
+        const [time, date] = dosDate(modified);
+        v.setUint16(10, time, true);
+        v.setUint16(12, date, true);
+        v.setUint32(18, zip64 ? 0xffffffff : 0, true);
+        v.setUint32(22, zip64 ? 0xffffffff : 0, true);
+        v.setUint16(26, name.length, true);
+        v.setUint16(28, extra.length, true);
+        local.set(name, 30);
+        local.set(extra, 30 + name.length);
+        await this.push(local);
+        const dataOffset = this.offset;
+        let crc = 0xffffffff;
+        let read = 0;
+        while (read < size) {
+            const chunk = new Uint8Array(await blob.slice(read, Math.min(size, read + READ)).arrayBuffer());
+            crc = crc32Update(crc, chunk);
+            read += chunk.byteLength;
+            await this.push(chunk);
+            progress?.(read);
+        }
+        crc = (crc ^ 0xffffffff) >>> 0;
+        const descriptor = bytes(zip64 ? 24 : 16);
+        const d = view(descriptor);
+        d.setUint32(0, 0x08074b50, true);
+        d.setUint32(4, crc, true);
+        if (zip64) {
+            setU64(d, 8, size);
+            setU64(d, 16, size);
+        }
+        else {
+            d.setUint32(8, size, true);
+            d.setUint32(12, size, true);
+        }
+        await this.push(descriptor);
+        this.entries.push({ name, size, crc, localOffset, time, date });
+        return { offset: dataOffset, length: size, crc32: crc };
+    }
+    async close() {
+        const centralOffset = this.offset;
+        for (const entry of this.entries) {
+            const large = entry.size >= 0xffffffff || entry.localOffset >= 0xffffffff;
+            const extra = large ? zip64Extra([entry.size, entry.size, entry.localOffset]) : new Uint8Array();
+            const central = bytes(46 + entry.name.length + extra.length);
+            const v = view(central);
+            v.setUint32(0, 0x02014b50, true);
+            v.setUint16(4, 45, true);
+            v.setUint16(6, large ? 45 : 20, true);
+            v.setUint16(8, 0x0808, true);
+            v.setUint16(10, 0, true);
+            v.setUint16(12, entry.time, true);
+            v.setUint16(14, entry.date, true);
+            v.setUint32(16, entry.crc, true);
+            v.setUint32(20, large ? 0xffffffff : entry.size, true);
+            v.setUint32(24, large ? 0xffffffff : entry.size, true);
+            v.setUint16(28, entry.name.length, true);
+            v.setUint16(30, extra.length, true);
+            v.setUint32(42, large ? 0xffffffff : entry.localOffset, true);
+            central.set(entry.name, 46);
+            central.set(extra, 46 + entry.name.length);
+            await this.push(central);
+        }
+        const centralSize = this.offset - centralOffset;
+        const needs64 = this.entries.length >= 0xffff || centralOffset >= 0xffffffff || centralSize >= 0xffffffff;
+        if (needs64) {
+            const zip64Offset = this.offset;
+            const end64 = bytes(56);
+            const e = view(end64);
+            e.setUint32(0, 0x06064b50, true);
+            setU64(e, 4, 44);
+            e.setUint16(12, 45, true);
+            e.setUint16(14, 45, true);
+            setU64(e, 24, this.entries.length);
+            setU64(e, 32, this.entries.length);
+            setU64(e, 40, centralSize);
+            setU64(e, 48, centralOffset);
+            await this.push(end64);
+            const locator = bytes(20);
+            const l = view(locator);
+            l.setUint32(0, 0x07064b50, true);
+            setU64(l, 8, zip64Offset);
+            l.setUint32(16, 1, true);
+            await this.push(locator);
+        }
+        const end = bytes(22);
+        const e = view(end);
+        e.setUint32(0, 0x06054b50, true);
+        e.setUint16(8, Math.min(this.entries.length, 0xffff), true);
+        e.setUint16(10, Math.min(this.entries.length, 0xffff), true);
+        e.setUint32(12, Math.min(centralSize, 0xffffffff), true);
+        e.setUint32(16, Math.min(centralOffset, 0xffffffff), true);
+        await this.push(end);
+        await this.sink.close();
+    }
+    async push(data) {
+        await this.sink.write(data);
+        this.offset += data.byteLength;
+    }
+}
+async function makeVariants(file, wantThumb) {
+    const bitmap = await createImageBitmap(file, { imageOrientation: "from-image" });
+    try {
+        const displaySize = fit(bitmap.width, bitmap.height, 2048);
+        const display = await drawWebp(bitmap, displaySize.width, displaySize.height, .8);
+        let thumb;
+        if (wantThumb) {
+            const thumbSize = fit(bitmap.width, bitmap.height, 640);
+            thumb = await drawWebp(bitmap, thumbSize.width, thumbSize.height, .72);
+        }
+        return { display, thumb, width: displaySize.width, height: displaySize.height };
+    }
+    finally {
+        bitmap.close();
+    }
+}
+async function drawWebp(bitmap, width, height, quality) {
+    if (typeof OffscreenCanvas !== "undefined") {
+        const canvas = new OffscreenCanvas(width, height);
+        const ctx = canvas.getContext("2d", { alpha: false });
+        if (!ctx)
+            throw new Error("Canvas 2D non disponibile");
+        ctx.drawImage(bitmap, 0, 0, width, height);
+        return canvas.convertToBlob({ type: "image/webp", quality });
+    }
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext("2d", { alpha: false });
+    if (!ctx)
+        throw new Error("Canvas 2D non disponibile");
+    ctx.drawImage(bitmap, 0, 0, width, height);
+    return new Promise((resolve, reject) => canvas.toBlob((blob) => blob ? resolve(blob) : reject(new Error("Conversione WebP non riuscita")), "image/webp", quality));
+}
+function fit(width, height, edge) {
+    const scale = Math.min(1, edge / Math.max(width, height));
+    return { width: Math.max(1, Math.round(width * scale)), height: Math.max(1, Math.round(height * scale)) };
+}
+async function postJson(body) {
+    const res = await fetch("/admin/api/delivery/multipart", {
+        method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body),
+    });
+    const answer = await res.json().catch(() => ({}));
+    if (!res.ok || answer.ok === false)
+        throw new Error(answer.error || `HTTP ${res.status}`);
+    return answer;
+}
+export function setDeliveryRelativePath(file, path) {
+    droppedPaths.set(file, safePath(path));
+}
+export function deliveryRelativeName(file) {
+    return droppedPaths.get(file) || file.webkitRelativePath || file.name;
+}
+export function deliverySelectionName(files) {
+    const first = files[0];
+    if (!first)
+        return "";
+    const path = deliveryRelativeName(first).replace(/\\/g, "/");
+    const slash = path.indexOf("/");
+    return slash > 0 ? path.slice(0, slash) : first.name.replace(/\.[^.]+$/, "") || first.name;
+}
+export async function uploadDeliveryHeroObject(deliveryId, packageId, file) {
+    const variant = await makeHeroVariant(file);
+    const signed = await postJson({
+        action: "heroPresign", id: deliveryId, packageId,
+    });
+    const response = await fetch(signed.url, {
+        method: "PUT", body: variant.blob, headers: { "Content-Type": "image/webp" },
+    });
+    if (!response.ok)
+        throw new Error(`Copertina non caricata (${response.status}). Riprova.`);
+    return {
+        type: "object", id: signed.heroId, sourceName: deliveryRelativeName(file),
+        width: variant.width, height: variant.height, bytes: variant.blob.size,
+    };
+}
+async function makeHeroVariant(file) {
+    if (!IMAGE.test(file.name))
+        throw new Error("La copertina dev’essere un’immagine JPEG, PNG o WebP");
+    const bitmap = await createImageBitmap(file, { imageOrientation: "from-image" });
+    try {
+        const size = fit(bitmap.width, bitmap.height, 2560);
+        return {
+            blob: await drawWebp(bitmap, size.width, size.height, .82),
+            width: size.width, height: size.height,
+        };
+    }
+    finally {
+        bitmap.close();
+    }
+}
+export async function deliverySourceFingerprint(files) {
+    const lines = [...files]
+        .sort((a, b) => deliveryRelativeName(a).localeCompare(deliveryRelativeName(b), undefined, {
+        numeric: true, sensitivity: "base",
+    }))
+        .map((file) => `${safePath(deliveryRelativeName(file))}\0${file.size}\0${file.lastModified}`)
+        .join("\n");
+    return digestHex(enc.encode(lines));
+}
+function safePath(input) {
+    const parts = String(input).replace(/\\/g, "/").split("/")
+        .filter((part) => part && part !== "." && part !== "..");
+    return parts.join("/") || "file";
+}
+function mimeFromName(name) {
+    const ext = name.split(".").pop()?.toLowerCase();
+    return { jpg: "image/jpeg", jpeg: "image/jpeg", png: "image/png", webp: "image/webp",
+        tif: "image/tiff", tiff: "image/tiff", pdf: "application/pdf" }[ext || ""] ||
+        "application/octet-stream";
+}
+function bytes(size) { return new Uint8Array(size); }
+function view(value) { return new DataView(value.buffer, value.byteOffset, value.byteLength); }
+function setU64(v, offset, value) {
+    v.setUint32(offset, value >>> 0, true);
+    v.setUint32(offset + 4, Math.floor(value / 0x100000000), true);
+}
+function zip64Extra(values) {
+    const out = bytes(4 + values.length * 8);
+    const v = view(out);
+    v.setUint16(0, 0x0001, true);
+    v.setUint16(2, values.length * 8, true);
+    values.forEach((value, i) => setU64(v, 4 + i * 8, value));
+    return out;
+}
+function dosDate(date) {
+    const year = Math.max(1980, date.getFullYear());
+    return [
+        (date.getHours() << 11) | (date.getMinutes() << 5) | Math.floor(date.getSeconds() / 2),
+        ((year - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate(),
+    ];
+}
+const CRC_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        table[n] = c >>> 0;
+    }
+    return table;
+})();
+function crc32Update(crc, data) {
+    let c = crc;
+    for (let i = 0; i < data.length; i++)
+        c = CRC_TABLE[(c ^ data[i]) & 0xff] ^ (c >>> 8);
+    return c >>> 0;
+}
+function delay(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
+async function digestHex(data) {
+    const digest = await crypto.subtle.digest("SHA-256", data.buffer);
+    return [...new Uint8Array(digest)]
+        .map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}

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

@@ -0,0 +1,9 @@
+import type * as z from "zod";
+type Shape = Record<string, z.ZodType>;
+/** I nomi dei gruppi, nell'ordine di dichiarazione. Salta i campi nascosti. */
+export declare function groupsOf(shape: Shape): string[];
+/** I campi che NON appartengono al gruppo: è la forma che vuole `omit` di SchemaForm. */
+export declare function fieldsOutside(shape: Shape, group: string): string[];
+/** Nome del gruppo -> pezzo di indirizzo. Serve solo a poter tornare su una sezione col link. */
+export declare function groupSlug(group: string): string;
+export {};

package/dist/app/lib/groups.js

@@ -0,0 +1,32 @@
+/* I gruppi di uno schema, letti dal registro `ui`.
+ *
+ * Servono alla seconda colonna della home: le sue sezioni non sono un elenco scritto a mano da
+ * qualche parte, sono i `group` dichiarati nello schema — nell'ordine in cui compaiono, che è
+ * anche l'ordine del file su disco. Aggiungere una sezione allo schema la fa comparire nella
+ * colonna senza toccare niente qui, esattamente come succede al form.
+ */
+import { ui } from "../../index.js";
+/** I nomi dei gruppi, nell'ordine di dichiarazione. Salta i campi nascosti. */
+export function groupsOf(shape) {
+    const out = [];
+    for (const field of Object.values(shape)) {
+        const meta = ui.get(field);
+        if (!meta || meta.widget === "hidden")
+            continue;
+        const g = meta.group ?? "";
+        if (!out.includes(g))
+            out.push(g);
+    }
+    return out;
+}
+/** I campi che NON appartengono al gruppo: è la forma che vuole `omit` di SchemaForm. */
+export function fieldsOutside(shape, group) {
+    return Object.entries(shape)
+        .filter(([, field]) => (ui.get(field)?.group ?? "") !== group)
+        .map(([name]) => name);
+}
+/** Nome del gruppo -> pezzo di indirizzo. Serve solo a poter tornare su una sezione col link. */
+export function groupSlug(group) {
+    return group.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "")
+        .replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "generale";
+}

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

@@ -0,0 +1,11 @@
+export declare function useHome(active: boolean): {
+    data: Record<string, unknown> | null;
+    error: string | null;
+    dirty: boolean;
+    saving: boolean;
+    notice: string | null;
+    load: () => Promise<void>;
+    change: (next: Record<string, unknown>) => void;
+    save: () => Promise<void>;
+    setNotice: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+};