@cardinali-studio/adminkit 1.0.0

package/dist/functions/index.js

@@ -0,0 +1,124 @@
+/* LO SMISTATORE: l'ingresso `./functions` del kit.
+ *
+ * Cloudflare Pages instrada le Functions PER FILE, e un pacchetto npm non può mettere file
+ * dentro `functions/`. Quindi il sito ne tiene due, entrambi da una riga — un acchiappatutto su
+ * `/admin/api/*` e il controllo d'accesso — e tutto il resto vive qui.
+ *
+ *   functions/admin/api/[[path]].js   ->  handleAdminApi(context, config)
+ *   functions/admin/_middleware.js    ->  adminAccess
+ *
+ * L'acchiappatutto è ristretto a `…/api/*` di proposito: uno un livello più in alto passerebbe
+ * per lo smistatore anche i file statici del pannello. Restano invece sotto il middleware — che
+ * è giusto, perché l'HTML e il JS del pannello devono stare dietro Access esattamente come le
+ * sue API (verificato: senza le variabili di Access, anche `/admin/index.html` risponde 503).
+ *
+ * COSA QUESTO SOSTITUISCE, e cosa no. Rifà la corrispondenza fra percorso e gestore, che è
+ * l'unica cosa che serviva. NON rifà i segmenti variabili (`[id].js`): oggi nessuna rotta ne ha
+ * — l'unica che li usava era Prenotazioni, che in v1.0 resta al sito. Aggiungerli adesso
+ * sarebbe macchinario per un caso che non esiste; si aggiungono quando arriva.
+ *
+ * ⚠️ Un sito può tenersi endpoint PROPRI accanto a questi: Cloudflare instrada prima le rotte
+ * più specifiche, quindi un `functions/admin/api/booking/index.js` del sito vince
+ * sull'acchiappatutto (verificato, non dedotto). È il motivo per cui Prenotazioni può restare
+ * dov'è senza inventare nessun punto di innesto.
+ */
+import { setServerConfig, moduleEnabled } from "./site.js";
+
+import * as analytics from "./api/analytics.js";
+import * as assets from "./api/assets.js";
+import * as assetsDelete from "./api/assets/delete.js";
+import * as assetsFolder from "./api/assets/folder.js";
+import * as assetsFolders from "./api/assets/folders.js";
+import * as assetsMove from "./api/assets/move.js";
+import * as assetsPreview from "./api/assets/preview.js";
+import * as assetsTrash from "./api/assets/trash.js";
+import * as assetsTrashDelete from "./api/assets/trash/delete.js";
+import * as assetsTrashEmpty from "./api/assets/trash/empty.js";
+import * as assetsTrashRestore from "./api/assets/trash/restore.js";
+import * as assetsUpload from "./api/assets/upload.js";
+import * as assetsUsage from "./api/assets/usage.js";
+import * as deliveries from "./api/deliveries.js";
+import * as deliveryHero from "./api/delivery/hero.js";
+import * as deliveryImage from "./api/delivery/image.js";
+import * as deliveryMultipart from "./api/delivery/multipart.js";
+import * as pages from "./api/pages.js";
+import * as pagesGet from "./api/pages/get.js";
+import * as publish from "./api/publish.js";
+import * as requests from "./api/requests.js";
+import * as settings from "./api/settings.js";
+import * as singleton from "./api/singleton.js";
+import * as storage from "./api/storage.js";
+
+export { adminAccess } from "./_middleware.js";
+export { setServerConfig } from "./site.js";
+
+/* La tabella. `module` dice a quale interruttore appartiene una rotta: `null` = sempre presente.
+ *
+ * Oggi l'unico modulo che spegne le proprie rotte è Consegne, ed è deliberato: spegnerne altre
+ * cambierebbe come si comporta un pannello già in uso, e la v1.0 ha una lista ENUMERATA di
+ * cambiamenti di comportamento a cui attenersi. Gli altri interruttori arrivano quando c'è modo
+ * di verificarli uno per uno. */
+const ROUTES = {
+  "analytics": { mod: null, h: analytics },
+  "assets": { mod: null, h: assets },
+  "assets/delete": { mod: null, h: assetsDelete },
+  "assets/folder": { mod: null, h: assetsFolder },
+  "assets/folders": { mod: null, h: assetsFolders },
+  "assets/move": { mod: null, h: assetsMove },
+  "assets/preview": { mod: null, h: assetsPreview },
+  "assets/trash": { mod: null, h: assetsTrash },
+  "assets/trash/delete": { mod: null, h: assetsTrashDelete },
+  "assets/trash/empty": { mod: null, h: assetsTrashEmpty },
+  "assets/trash/restore": { mod: null, h: assetsTrashRestore },
+  "assets/upload": { mod: null, h: assetsUpload },
+  "assets/usage": { mod: null, h: assetsUsage },
+  "deliveries": { mod: "delivery", h: deliveries },
+  "delivery/hero": { mod: "delivery", h: deliveryHero },
+  "delivery/image": { mod: "delivery", h: deliveryImage },
+  "delivery/multipart": { mod: "delivery", h: deliveryMultipart },
+  "pages": { mod: null, h: pages },
+  "pages/get": { mod: null, h: pagesGet },
+  "publish": { mod: null, h: publish },
+  "requests": { mod: null, h: requests },
+  "settings": { mod: null, h: settings },
+  "singleton": { mod: null, h: singleton },
+  "storage": { mod: null, h: storage },
+};
+
+const PREFIX = "/admin/api/";
+
+function json(data, status) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json", "Cache-Control": "no-store" },
+  });
+}
+
+export async function handleAdminApi(context, config) {
+  setServerConfig(config);
+
+  const url = new URL(context.request.url);
+  if (!url.pathname.startsWith(PREFIX)) return json({ ok: false, error: "rotta fuori da /admin/api/" }, 404);
+
+  /* Le barre di troppo e finali non fanno una rotta diversa: `/assets/` e `/assets` sono la
+   * stessa cosa per chi la scrive, e farle divergere produce un 404 che sembra un guasto. */
+  const path = url.pathname.slice(PREFIX.length).split("/").filter(Boolean).join("/");
+  const route = ROUTES[path];
+  if (!route) return json({ ok: false, error: "rotta sconosciuta" }, 404);
+
+  /* Un modulo spento risponde 404, non 403: dall'esterno quella funzione non esiste, e un 403
+   * racconterebbe che esiste ma è vietata. */
+  if (route.mod && !moduleEnabled(route.mod)) {
+    return json({ ok: false, error: `Funzione "${route.mod}" non attiva.`, code: "feature_inactive" }, 404);
+  }
+
+  const method = context.request.method.toUpperCase();
+  const handler = route.h[`onRequest${method.charAt(0)}${method.slice(1).toLowerCase()}`] ?? route.h.onRequest;
+  if (!handler) {
+    /* 405 e non 404: la rotta c'è, è il verbo a non esserci. La differenza conta quando si
+     * cerca il guasto — «non esiste» e «non così» portano a cercare in due posti diversi. */
+    return json({ ok: false, error: "metodo non ammesso" }, 405);
+  }
+
+  return handler({ ...context, config });
+}

package/dist/functions/site.js

@@ -0,0 +1,38 @@
+/* LA GIUNTURA lato Worker: ciò che gli endpoint non possono sapere da soli.
+ *
+ * Gemella di `src/app/site.ts`, che fa la stessa cosa per l'interfaccia. Sono due perché sono
+ * due mondi diversi — uno gira nel browser e conosce React, l'altro gira in un Worker e non
+ * deve nemmeno vederlo — ma il sito le riempie **dalla stessa dichiarazione**: `site.config`
+ * è dati puri, quindi lo importano entrambi senza che React finisca dentro il Worker.
+ *
+ * Prima queste cose arrivavano con un `import` diretto dallo schema del cliente (e, in un caso,
+ * con un `import` del suo `data/site.json` — cioè un percorso che usciva dal pacchetto, che in
+ * un pacchetto pubblicato semplicemente non esiste).
+ *
+ * ⚠️ Provvisoria quanto la sua gemella: in v1.1, con gli schemi per tipo, `page` diventa una
+ * mappa e metà di questi campi sparisce. Vedi l'intestazione di `src/app/site.ts`.
+ */
+
+let current = null;
+
+/** Chiamata dallo smistatore a ogni richiesta: il valore è costante per deploy, riscriverlo
+ *  è idempotente e costa niente. */
+export function setServerConfig(config) {
+  current = config;
+}
+
+export function site() {
+  if (!current) {
+    throw new Error(
+      "adminkit: configurazione del sito non impostata. " +
+      "Gli endpoint si servono passando da `handleAdminApi(context, config)`.",
+    );
+  }
+  return current;
+}
+
+/** Un modulo è acceso? Ciò che non è dichiarato è SPENTO: un interruttore dimenticato deve
+ *  produrre una funzione assente, non una accesa per sbaglio. */
+export function moduleEnabled(name) {
+  return current?.modules?.[name] === true;
+}

package/dist/gallery.d.ts

@@ -0,0 +1,28 @@
+export type GalleryImage = {
+    src: string;
+    w?: number | null;
+    h?: number | null;
+    hidden?: boolean;
+};
+export type SectionType = "header" | "text" | "image" | "gallery";
+/** Una sezione della pagina gallery. Ha TUTTI i campi qualunque sia il tipo: Zod e React vogliono
+ *  una forma stabile, e l'encoder emette poi solo quelli pertinenti (vedi `sections` più sotto). */
+export interface PageSection {
+    id: string;
+    type: SectionType;
+    eyebrow: string;
+    heading: string;
+    lead: string;
+    paragraphs: string[];
+    image: string;
+    w: number | null;
+    h: number | null;
+    alt: string;
+    caption: string;
+    layout: "wide" | "contained";
+    images: GalleryImage[];
+}
+export declare const GALLERY_BLOCK_ID = "gallery";
+/** Una sezione ai valori di riposo. Un posto solo in cui aggiungere un campo, invece di due
+ *  (qui e nell'admin) che nessuno modifica insieme. */
+export declare function emptySection(type: SectionType, id: string): PageSection;

package/dist/gallery.js

@@ -0,0 +1,18 @@
+/* L'id del blocco gallery quando non ce l'ha ancora: lo usano la migrazione qui sotto e l'admin,
+ * che il blocco lo mostra sempre anche quando il front matter non lo contiene.
+ * È COSTANTE, e non generato come gli altri (`Date.now()` + random): un id nuovo a ogni render
+ * darebbe a dnd-kit una chiave nuova ogni volta, la card verrebbe rimontata di continuo e
+ * trascinarla diventerebbe impossibile. */
+export const GALLERY_BLOCK_ID = "gallery";
+/** Una sezione ai valori di riposo. Un posto solo in cui aggiungere un campo, invece di due
+ *  (qui e nell'admin) che nessuno modifica insieme. */
+export function emptySection(type, id) {
+    return {
+        id, type,
+        eyebrow: "", heading: "", lead: "",
+        paragraphs: [],
+        image: "", w: null, h: null, alt: "", caption: "",
+        layout: "wide",
+        images: [],
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./config.js";
+export * from "./registries.js";
+export * from "./frontmatter.js";
+export * from "./yaml.js";
+export * from "./serialize.js";
+export * from "./model.js";
+export * from "./api.js";
+export * from "./prose.js";
+export * from "./gallery.js";
+export * from "./normalize.js";

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from "./config.js";
+export * from "./registries.js";
+export * from "./frontmatter.js";
+export * from "./yaml.js";
+export * from "./serialize.js";
+export * from "./model.js";
+export * from "./api.js";
+export * from "./prose.js";
+export * from "./gallery.js";
+export * from "./normalize.js";

package/dist/model.d.ts

@@ -0,0 +1,2 @@
+import type { Shape, Model } from "./serialize.js";
+export declare function modelFromRaw(raw: Record<string, unknown>, shape: Shape, extra?: Model): Model;

package/dist/model.js

@@ -0,0 +1,47 @@
+/* Costruisce il modello di un elemento dal front matter GREZZO, senza passare dal markdown.
+ * È la via che serve al manifest: Hugo emette i parametri così come sono nel file, e la
+ * conversione — il flip visible/published, la presenza del blocco `menu` — la fa lo schema.
+ * È l'unico modo per avere quella conversione in un posto solo: i template Hugo non possono
+ * importare TypeScript, quindi devono smettere di conoscerla del tutto. */
+import { fm } from "./registries.js";
+export function modelFromRaw(raw, shape, extra = {}) {
+    const normalized = withSchemaCasing(raw, shape);
+    const model = { ...extra };
+    for (const [name, field] of Object.entries(shape)) {
+        const meta = fm.get(field);
+        if (!meta)
+            continue;
+        const v = meta.decode(normalized, { raw: normalized });
+        if (v !== undefined)
+            model[name] = v;
+    }
+    return model;
+}
+/* HUGO MINUSCOLIZZA LE CHIAVI DEI PARAMETRI. `r2Prefix` nel file diventa `r2prefix` in
+ * `.Params`, `isHome` diventa `ishome`. Le `decode` sono scritte con la grafia del FILE — che è
+ * quella giusta, ed è quella che vede il serializzatore — quindi leggendo dal manifest non
+ * troverebbero niente e restituirebbero un valore vuoto.
+ *
+ * Non è teorico: `r2Prefix` spariva da tutte e quattro le gallery. E `isHome` sembrava
+ * funzionare solo perché vale `false` ovunque — con una pagina a `true` avrebbe sbagliato in
+ * silenzio, che è il modo peggiore.
+ *
+ * Qui si rimettono le chiavi nella grafia dichiarata dallo schema. Solo per quelle dichiarate:
+ * non è una normalizzazione generale, è una riconciliazione fra due sorgenti che chiamano la
+ * stessa cosa in due modi. */
+function withSchemaCasing(raw, shape) {
+    const lower = new Map();
+    for (const [k, v] of Object.entries(raw))
+        lower.set(k.toLowerCase(), v);
+    const out = { ...raw };
+    for (const field of Object.values(shape)) {
+        for (const key of fm.get(field)?.keys ?? []) {
+            if (Object.prototype.hasOwnProperty.call(out, key))
+                continue;
+            const hit = lower.get(key.toLowerCase());
+            if (hit !== undefined)
+                out[key] = hit;
+        }
+    }
+    return out;
+}

package/dist/normalize.d.ts

@@ -0,0 +1,50 @@
+export type Credit = {
+    label: string;
+    name: string;
+    href: string;
+};
+export declare function normalizeCredits(value: unknown): Credit[];
+export type WorkCardType = "image" | "text" | "frosted";
+export type WorkInfo = {
+    label: string;
+    value: string;
+};
+export type WorkCard = {
+    type: WorkCardType;
+    image: string;
+    alt: string;
+    kicker: string;
+    heading: string;
+    body: string[];
+};
+export type Work = {
+    title: string;
+    cover: string;
+    description: string[];
+    info: WorkInfo[];
+    cards: WorkCard[];
+};
+export declare const CARD_KINDS: {
+    type: WorkCardType;
+    label: string;
+    hint: string;
+}[];
+export declare function emptyWork(): Work;
+export declare function emptyCard(type: WorkCardType): WorkCard;
+export declare function normalizeWorks(value: unknown): Work[];
+export type WorkshopBlock = {
+    heading: string;
+    body: string[];
+};
+export type Workshop = {
+    image: string;
+    kicker: string;
+    title: string;
+    lead: string;
+    blocks: WorkshopBlock[];
+};
+export declare function emptyWorkshop(): Workshop;
+export declare function normalizeWorkshops(value: unknown): Workshop[];
+import { type PageSection } from "./gallery.js";
+export declare function normalizeSections(value: unknown): PageSection[];
+export declare function withGalleryBlock(sections: PageSection[]): PageSection[];

package/dist/normalize.js

@@ -0,0 +1,120 @@
+/* I NORMALIZZATORI degli editor per tipo di pagina, e i tipi che portano con sé.
+ *
+ * Stavano dentro i rispettivi componenti React. Sono qui per due ragioni, e la seconda è quella
+ * che conta:
+ *
+ *   1. Sono logica pura — nessun JSX, nessuno stato, nessun hook — e stare dentro un file
+ *      `.tsx` non le rendeva tali, le nascondeva soltanto.
+ *
+ *   2. SERVONO FUORI DALL'INTERFACCIA. Ogni sito deve poter verificare che normalizzare i
+ *      PROPRI contenuti veri non li cambi: l'editor rimanda indietro la lista normalizzata, non
+ *      quella che ha ricevuto, quindi se normalizzare alterasse anche un carattere, la prima
+ *      modifica a un campo qualunque riscriverebbe in silenzio tutte le altre voci — e nel diff
+ *      comparirebbero righe che nessuno ha toccato. Quella verifica gira in Node, dove React non
+ *      c'è: importarla da un `.tsx` trascinerebbe l'intera interfaccia dentro una suite di test.
+ *
+ * Il modo in cui quella garanzia veniva ottenuta prima è istruttivo: il test del sito APRIVA il
+ * file `.tsx` dell'editor e ne ritagliava la funzione col testo, «perché una copia è un posto in
+ * più in cui divergere». Aveva ragione sul problema e non aveva alternative sulla soluzione.
+ * Con un pacchetto l'alternativa c'è, ed è questa.
+ */
+const str = (value) => (typeof value === "string" ? value : "");
+const list = (value) => (Array.isArray(value) ? value : []);
+const obj = (value) => (value ?? {});
+export function normalizeCredits(value) {
+    return list(value).map((raw) => {
+        const item = obj(raw);
+        return { label: str(item.label), name: str(item.name), href: str(item.href) };
+    });
+}
+export const CARD_KINDS = [
+    { type: "image", label: "Immagine", hint: "Una fotografia a tutta larghezza" },
+    { type: "text", label: "Testo", hint: "Titolo e paragrafi" },
+    { type: "frosted", label: "Testo su immagine", hint: "Parole sopra una fotografia" },
+];
+export function emptyWork() {
+    return { title: "", cover: "", description: [], info: [], cards: [] };
+}
+/* Il tipo di una card nuova è SEMPRE esplicito, mai stringa vuota: un `select` mostra comunque
+ * la prima opzione quando il valore non combacia con nessuna, quindi una card salvata senza
+ * toccare il campo finirebbe nel file con `type: ""` — un valore che non corrisponde a nessun
+ * ramo del template, cioè una card vuota sul sito. È già successo. */
+export function emptyCard(type) {
+    return { type, image: "", alt: "", kicker: "", heading: "", body: [] };
+}
+export function normalizeWorks(value) {
+    return list(value).map((raw) => {
+        const item = obj(raw);
+        return {
+            title: str(item.title),
+            cover: str(item.cover),
+            description: list(item.description).map(str).filter(Boolean),
+            info: list(item.info).map((entry) => {
+                const o = obj(entry);
+                return { label: str(o.label), value: str(o.value) };
+            }),
+            cards: list(item.cards).map((entry) => {
+                const o = obj(entry);
+                const type = String(o.type);
+                return {
+                    ...emptyCard(CARD_KINDS.some((k) => k.type === type) ? type : "image"),
+                    image: str(o.image),
+                    alt: str(o.alt),
+                    kicker: str(o.kicker),
+                    heading: str(o.heading),
+                    body: list(o.body).map(str),
+                };
+            }),
+        };
+    });
+}
+export function emptyWorkshop() {
+    return { image: "", kicker: "", title: "", lead: "", blocks: [] };
+}
+export function normalizeWorkshops(value) {
+    return list(value).map((raw) => {
+        const item = obj(raw);
+        return {
+            image: str(item.image),
+            kicker: str(item.kicker),
+            title: str(item.title),
+            lead: str(item.lead),
+            blocks: list(item.blocks).map((entry) => {
+                const block = obj(entry);
+                return { heading: str(block.heading), body: list(block.body).map(str) };
+            }),
+        };
+    });
+}
+/* ---- Gallery: le sezioni ------------------------------------------------------------------- */
+import { emptySection, GALLERY_BLOCK_ID } from "./gallery.js";
+export function normalizeSections(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((raw, index) => {
+        const item = (raw ?? {});
+        if (!["header", "text", "image", "gallery"].includes(String(item.type)))
+            return null;
+        return {
+            ...emptySection(item.type, String(item.id || `section-${index + 1}`)),
+            ...item,
+            id: String(item.id || `section-${index + 1}`),
+            paragraphs: Array.isArray(item.paragraphs) ? item.paragraphs.map(String) : [],
+            w: Number(item.w) > 0 ? Number(item.w) : null,
+            h: Number(item.h) > 0 ? Number(item.h) : null,
+            layout: item.layout === "contained" ? "contained" : "wide",
+            images: Array.isArray(item.images) ? item.images : [],
+        };
+    })
+        .filter((item) => !!item);
+}
+/* Il blocco delle foto c'è sempre. Se il front matter non lo contiene ancora — una gallery mai
+ * salvata dal pannello, o una pagina appena diventata gallery — lo si aggiunge in coda, che è
+ * dove la griglia usciva prima che questo blocco esistesse. Vive solo nella vista finché
+ * l'utente non tocca qualcosa: aprire una pagina non deve sporcarla. */
+export function withGalleryBlock(sections) {
+    return sections.some((section) => section.type === "gallery")
+        ? sections
+        : [...sections, emptySection("gallery", GALLERY_BLOCK_ID)];
+}

package/dist/preview.d.ts

@@ -0,0 +1,3 @@
+/** Vero solo su un'anteprima locale. In produzione la scheda non va nemmeno emessa. */
+export declare function isLocalPreview(): boolean;
+export declare function Preview(): import("react").JSX.Element;

package/dist/preview.js

@@ -0,0 +1,82 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/* Pannello "Anteprima": mostra dentro l'admin lo stato dell'anteprima locale gestita da Regia.
+ *
+ * Due cose da tenere a mente, perché sembrano mancanze e non lo sono:
+ *
+ * 1. Da qui si può solo FERMARE e RIAVVIARE. Non accendere: per vedere questa pagina il sito
+ *    deve già girare, quindi l'accensione non può che vivere nel cruscotto di Regia. È un
+ *    limite del mezzo, e va scritto nell'interfaccia o sembra una funzione dimenticata.
+ * 2. Regia è facoltativa. Se il demone non c'è il pannello lo dice e basta: niente errori
+ *    rumorosi, niente riprove, e soprattutto nessuna dipendenza dell'admin da uno strumento
+ *    che su un'altra macchina potrebbe non essere installato.
+ */
+import { useCallback, useEffect, useState } from "react";
+const DAEMON_PORT = 7391;
+const DAEMON = `http://127.0.0.1:${DAEMON_PORT}`;
+/** Vero solo su un'anteprima locale. In produzione la scheda non va nemmeno emessa. */
+export function isLocalPreview() {
+    if (typeof location === "undefined")
+        return false;
+    return location.hostname === "localhost" || location.hostname === "127.0.0.1";
+}
+const STATE_TEXT = {
+    running: "attiva",
+    starting: "in avvio…",
+    stopped: "ferma",
+    crashed: "caduta",
+    failed: "avvio fallito",
+};
+export function Preview() {
+    const [status, setStatus] = useState({ kind: "loading" });
+    const [busy, setBusy] = useState(false);
+    const load = useCallback(async () => {
+        const port = location.port || (location.protocol === "https:" ? "443" : "80");
+        try {
+            const res = await fetch(`${DAEMON}/api/whoami?port=${encodeURIComponent(port)}`);
+            if (res.status === 404)
+                return setStatus({ kind: "unmanaged" });
+            if (!res.ok)
+                return setStatus({ kind: "absent" });
+            const data = (await res.json());
+            setStatus({ kind: "site", site: data.site, dashboard: data.dashboard });
+        }
+        catch {
+            // Il demone non risponde: non è un errore dell'admin, è uno strumento assente.
+            setStatus({ kind: "absent" });
+        }
+    }, []);
+    useEffect(() => {
+        void load();
+    }, [load]);
+    const act = async (action) => {
+        if (status.kind !== "site")
+            return;
+        if (action === "stop" && !confirm("Fermare l'anteprima? Questa pagina smetterà di rispondere."))
+            return;
+        setBusy(true);
+        try {
+            await fetch(`${DAEMON}/api/sites/${encodeURIComponent(status.site.id)}/${action}`, { method: "POST" });
+        }
+        catch {
+            /* se il riavvio uccide la connessione va bene così: si ricarica sotto */
+        }
+        setBusy(false);
+        if (action === "restart") {
+            // Dopo un riavvio il server torna su con qualche secondo di ritardo.
+            setTimeout(() => void load(), 2500);
+        }
+        else {
+            void load();
+        }
+    };
+    if (status.kind === "loading")
+        return _jsx("p", { className: "ak-hint", children: "Controllo\u2026" });
+    if (status.kind === "absent") {
+        return (_jsx("div", { className: "rg", children: _jsxs("p", { className: "ak-hint", children: ["Regia non \u00E8 in esecuzione, quindi questa anteprima non \u00E8 pilotabile da qui. Apri l'icona ", _jsx("strong", { children: "Regia" }), ", oppure il cruscotto: ", _jsxs("a", { href: `${DAEMON}/`, children: [DAEMON, "/"] })] }) }));
+    }
+    if (status.kind === "unmanaged") {
+        return (_jsx("div", { className: "rg", children: _jsx("p", { className: "ak-hint", children: "Questa anteprima non \u00E8 gestita da Regia: \u00E8 stata avviata in un altro modo, quindi va fermata dove \u00E8 stata accesa." }) }));
+    }
+    const { site, dashboard } = status;
+    return (_jsxs("div", { className: "rg", children: [_jsxs("header", { className: "rg-top", children: [_jsx("span", { className: `rg-dot rg-dot-${site.state}`, "aria-hidden": "true" }), _jsx("span", { className: "rg-name", children: site.name }), _jsxs("span", { className: "ak-hint", children: ["anteprima ", STATE_TEXT[site.state], " \u00B7 porta ", site.port] }), _jsx("span", { className: "ak-spacer" }), _jsx("button", { className: "ak-btn ak-btn-quiet", disabled: busy, onClick: () => void act("restart"), children: "Riavvia" }), _jsx("button", { className: "ak-btn", disabled: busy, onClick: () => void act("stop"), children: "Ferma" })] }), site.message && _jsx("p", { className: "ak-hint", children: site.message }), _jsxs("p", { className: "ak-hint", children: ["Da qui si pu\u00F2 solo fermare o riavviare: per accendere un'anteprima serve il cruscotto, ", _jsx("a", { href: dashboard, children: dashboard })] }), site.lan && site.urls.lan.length > 0 ? (_jsxs("div", { className: "rg-lan", children: [_jsxs("div", { className: "rg-lan-urls", children: [_jsxs("p", { className: "ak-hint", children: ["Dal telefono, sulla stessa rete \u2014 si vede ", _jsx("strong", { children: "il sito" }), ": questo pannello no, perch\u00E9 la via d'uscita di Access vale solo su un hostname locale."] }), site.urls.lan.map((l) => (_jsxs("div", { children: [_jsx("a", { href: l.url, children: l.url }), l.kind === "mdns" && _jsx("span", { className: "ak-hint", children: " \u2014 se il nome non risponde, usa l'indirizzo numerico" })] }, l.url)))] }), _jsx("img", { className: "rg-qr", alt: "Codice QR dell'indirizzo di rete", src: `${DAEMON}/api/sites/${encodeURIComponent(site.id)}/qr.svg?url=${encodeURIComponent(site.urls.lan[0].url)}` })] })) : (_jsx("p", { className: "ak-hint", children: "Questa anteprima \u00E8 visibile solo da questo Mac. Per aprirla al telefono, accendi \u00ABSulla rete locale\u00BB nel cruscotto." }))] }));
+}

package/dist/prose.d.ts

@@ -0,0 +1,17 @@
+/** Un testo e la porzione selezionata dentro di lui. */
+export interface Selection {
+    text: string;
+    start: number;
+    end: number;
+}
+/** Il markdown come lo mostra il campo: un `<p>` per paragrafo, `<br>` per l'a capo singolo. */
+export declare function mdToHtml(md: string): string;
+/** Gli indirizzi che si possono scrivere in un collegamento.
+ *
+ *  `javascript:` è la ragione per cui questo controllo esiste: il markdown dell'admin finisce in
+ *  pagine renderizzate con `unsafe = true`, quindi un indirizzo non è un dato inerte. Si
+ *  accettano gli schemi che servono e i percorsi interni; tutto il resto è rifiutato invece di
+ *  essere ripulito, perché "ripulire" un indirizzo ostile è un gioco che si perde. */
+export declare function isSafeHref(href: string): boolean;
+/** Il testo del campo com'è da salvare: markdown. */
+export declare function htmlToMd(html: string): string;