@studiotitta/studio-editori 0.1.0

package/dist/selain/Paneeli.d.ts

@@ -0,0 +1,44 @@
+import type { Kentta } from "../maarittely.ts";
+import { asetaArvo, type Kentanpolku } from "./polku.ts";
+import type { SivunMalli } from "./tyypit.ts";
+export interface PaneelinTiedot {
+    /** Lataa kuvan; palauttaa osoitteen ja mahdollisen tekstiehdotuksen. */
+    lataaKuva(tiedosto: File, maaritys: Extract<Kentta, {
+        tyyppi: "kuva";
+    }>): Promise<{
+        src: string;
+        ehdotus: string | null;
+    }>;
+    sivu: string;
+    malli: SivunMalli;
+    data: Record<string, unknown>;
+    kieli: string;
+    /** Sivuston kaikki kielet. Kielivalinta näytetään vain, jos niitä on monta. */
+    kielet: string[];
+    /** Kentät, jotka näkyvät jo sivulla — ne muokataan paikallaan. */
+    sivullaNakyvat: Set<string>;
+    /** Valittu kohde kohdelistassa, jos sivulla on sellainen. */
+    valittu?: string;
+    /** Palvelimen hylkäämät kentät viimeisimmästä tallennuksesta. */
+    virheet?: {
+        kohde: string;
+        viesti: string;
+    }[];
+    /** Täyttää puuttuvat käännökset ehdotuksina; palauttaa tilaviestin. */
+    kaanna(mihin: "sivu" | "kohde"): Promise<string>;
+    /** Mitkä kentät odottavat käännöstä: sivun omat ja valitun kohteen. */
+    kaannettavia: {
+        sivu: string[];
+        kohde: string[];
+    };
+    /** Ovatko käännösehdotukset käytössä tällä sivustolla. */
+    kaannosKaytossa: boolean;
+    muuta(polku: Kentanpolku, arvo: unknown, kaannettava: boolean): void;
+    valitse(tunnus: string): void;
+    lisaaKohde(kentta: string, maaritys: Extract<Kentta, {
+        tyyppi: "kohdelista";
+    }>): void;
+    poistaKohde(kentta: string, tunnusKentta: string, tunnus: string): void;
+}
+export declare function Paneeli(tiedot: PaneelinTiedot): import("react").JSX.Element;
+export { asetaArvo };

package/dist/selain/Paneeli.js

@@ -0,0 +1,259 @@
+"use client";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/* ==========================================================================
+   SIVUPANEELI
+   ==========================================================================
+   Paneeli on sitä varten, mikä ei näy sivulla: ryhmäkoko, varatut paikat,
+   kurssin tila, näkyvyys ja hakukonetekstit. Sivulla näkyvät tekstit
+   muokataan paikallaan, ei täällä.
+
+   Paneeli rakentuu sisältömallista, jonka palvelin lähettää. Editoriin ei
+   siis kovakoodata mitään sivustokohtaista: kun sivusto lisää kentän, se
+   ilmestyy paneeliin oikeana säätimenä.
+   ========================================================================== */
+import { useState } from "react";
+import { asetaArvo, lueArvo, vapaaTunnus } from "./polku.js";
+function onOlio(arvo) {
+    return typeof arvo === "object" && arvo !== null && !Array.isArray(arvo);
+}
+/** Kentän arvo muokattavassa muodossa: käännettävästä vain nykyinen kieli. */
+function nykyinenArvo(maaritys, arvo, kieli) {
+    if ("kaannettava" in maaritys && maaritys.kaannettava) {
+        return onOlio(arvo) ? arvo[kieli] : undefined;
+    }
+    return arvo;
+}
+const KIELTEN_NIMET = {
+    fi: "suomeksi",
+    en: "englanniksi",
+    sv: "ruotsiksi",
+};
+function Sisalto({ maaritys, arvo, tunniste, muuta, lataa, kielet, }) {
+    switch (maaritys.tyyppi) {
+        case "luku":
+            return (_jsx("input", { id: tunniste, type: "number", inputMode: "numeric", value: typeof arvo === "number" ? arvo : "", min: maaritys.pienin, max: maaritys.suurin, onChange: (tapahtuma) => {
+                    const teksti = tapahtuma.target.value;
+                    muuta(teksti === "" ? undefined : Number(teksti));
+                } }));
+        case "valinta":
+            return (_jsx("select", { id: tunniste, value: typeof arvo === "string" ? arvo : "", onChange: (tapahtuma) => muuta(tapahtuma.target.value), children: maaritys.vaihtoehdot.map((vaihtoehto) => (_jsx("option", { value: vaihtoehto.arvo, children: vaihtoehto.nimi }, vaihtoehto.arvo))) }));
+        case "kytkin":
+            return (_jsxs("label", { className: "kytkin", children: [_jsx("input", { id: tunniste, type: "checkbox", checked: arvo === true, onChange: (tapahtuma) => muuta(tapahtuma.target.checked) }), _jsx("span", { children: maaritys.teksti ?? maaritys.nimi ?? "Kyllä" })] }));
+        case "aika": {
+            const teksti = typeof arvo === "string" ? arvo : "";
+            /* datetime-local tarvitsee muodon 2026-11-15T09:00 ilman aikavyöhykettä. */
+            const paikallinen = teksti.slice(0, maaritys.kellonaika ? 16 : 10);
+            return (_jsx("input", { id: tunniste, type: maaritys.kellonaika ? "datetime-local" : "date", value: paikallinen, onChange: (tapahtuma) => muuta(tapahtuma.target.value) }));
+        }
+        case "tekstialue":
+            return (_jsx("textarea", { id: tunniste, rows: 4, value: typeof arvo === "string" ? arvo : "", onChange: (tapahtuma) => muuta(tapahtuma.target.value) }));
+        case "tekstilista":
+            return (_jsx("textarea", { id: tunniste, rows: 5, value: Array.isArray(arvo) ? arvo.join("\n\n") : "", onChange: (tapahtuma) => muuta(tapahtuma.target.value
+                    .split(/\n{2,}/)
+                    .map((kohta) => kohta.trim())
+                    .filter((kohta) => kohta !== "")) }));
+        case "kielivalinta": {
+            const valitut = Array.isArray(arvo) ? arvo : [];
+            return (_jsxs("div", { className: "kielivalinta", children: [kielet.map((kieli) => (_jsxs("label", { className: "kytkin", children: [_jsx("input", { type: "checkbox", checked: valitut.includes(kieli), onChange: (tapahtuma) => muuta(tapahtuma.target.checked
+                                    ? [...kielet.filter((muu) => valitut.includes(muu) || muu === kieli)]
+                                    : valitut.filter((muu) => muu !== kieli)) }), _jsxs("span", { children: ["N\u00E4yt\u00E4 ", KIELTEN_NIMET[kieli] ?? kieli] })] }, kieli))), valitut.length === 0 ? (_jsx("p", { className: "huomio", children: "Kohde ei n\u00E4y mill\u00E4\u00E4n kielell\u00E4." })) : null] }));
+        }
+        case "kuva":
+            return _jsx(Kuvakentta, { maaritys: maaritys, arvo: arvo, muuta: muuta, lataa: lataa });
+        default:
+            return (_jsx("input", { id: tunniste, type: "text", value: typeof arvo === "string" ? arvo : "", onChange: (tapahtuma) => muuta(tapahtuma.target.value) }));
+    }
+}
+function Kentta_({ polku, maaritys, tiedot, }) {
+    const nimi = maaritys.nimi ?? polku.alikentta?.split(".").at(-1) ?? polku.kentta;
+    const tunniste = `kentta-${polku.kentta}-${polku.tunnus ?? ""}-${(polku.alikentta ?? "").replace(".", "-")}`;
+    const kaannettava = "kaannettava" in maaritys && maaritys.kaannettava === true;
+    const arvo = nykyinenArvo(maaritys, lueArvo(tiedot.data, polku), tiedot.kieli);
+    return (_jsxs("div", { className: "kentta", children: [_jsxs("label", { htmlFor: tunniste, children: [nimi, kaannettava ? _jsx("span", { className: "kieli", children: tiedot.kieli }) : null] }), _jsx(Sisalto, { maaritys: maaritys, arvo: arvo, tunniste: tunniste, kielet: tiedot.kielet, muuta: (uusi) => tiedot.muuta(polku, uusi, kaannettava), lataa: maaritys.tyyppi === "kuva"
+                    ? async (tiedosto) => {
+                        const { src, ehdotus } = await tiedot.lataaKuva(tiedosto, maaritys);
+                        const vanha = onOlio(arvo) ? arvo : {};
+                        /* Tyhjä teksti täytetään ehdotuksella suoraan; olemassa
+                           olevaa ei ylikirjoiteta, vaan ehdotus tarjotaan. */
+                        const alt = typeof vanha.alt === "string" ? vanha.alt.trim() : "";
+                        tiedot.muuta(polku, { ...vanha, src, ...(alt === "" && ehdotus ? { alt: ehdotus } : {}) }, false);
+                        return ehdotus;
+                    }
+                    : undefined }), _jsx(Vapaana, { polku: polku, maaritys: maaritys, arvo: arvo, tiedot: tiedot }), maaritys.ohje ? _jsx("p", { className: "ohje", children: maaritys.ohje }) : null] }));
+}
+/**
+ * Vapaat paikat laskettuna: ryhmäkoko miinus varatut.
+ *
+ * Tämä näkyy vain muokkaajalle. Kävijälle kerrotaan enintään ryhmäkoko —
+ * se, montako on jo ilmoittautunut, on tietoisesti hänen tietonsa
+ * ulkopuolella.
+ */
+function Vapaana({ polku, maaritys, arvo, tiedot, }) {
+    if (maaritys.tyyppi !== "luku" || !maaritys.enintaanKuin)
+        return null;
+    if (typeof arvo !== "number")
+        return null;
+    const yla = lueArvo(tiedot.data, { ...polku, alikentta: maaritys.enintaanKuin });
+    if (typeof yla !== "number")
+        return null;
+    const vapaana = Math.max(0, yla - arvo);
+    return (_jsx("p", { className: "laskuri", role: "status", children: vapaana === 0 ? "Täynnä" : `Vapaana ${vapaana} / ${yla} paikkaa` }));
+}
+export function Paneeli(tiedot) {
+    const kentat = Object.entries(tiedot.malli.kentat);
+    const lista = kentat.find(([, maaritys]) => maaritys.tyyppi === "kohdelista");
+    const nayta = ([avain, maaritys]) => {
+        /* Kielivalinta on turha, jos sivustolla on vain yksi kieli. */
+        if (maaritys.tyyppi === "kielivalinta" && tiedot.kielet.length < 2)
+            return false;
+        return !tiedot.sivullaNakyvat.has(`${tiedot.sivu}.${avain}`);
+    };
+    const omat = kentat.filter(([avain, maaritys]) => maaritys.tyyppi !== "kohdelista" && nayta([avain, maaritys]));
+    return (_jsxs("aside", { className: "paneeli", "aria-label": "Sis\u00E4ll\u00F6n tiedot", children: [tiedot.virheet && tiedot.virheet.length > 0 ? (_jsxs("section", { className: "virheet", role: "alert", children: [_jsx("h2", { children: "Tallennus pys\u00E4htyi" }), _jsx("ul", { children: tiedot.virheet.slice(0, 6).map((virhe) => (_jsxs("li", { children: [_jsx("strong", { children: virhe.kohde.split(".").at(-1) }), " ", virhe.viesti] }, `${virhe.kohde}-${virhe.viesti}`))) })] })) : null, omat.length > 0 || tiedot.kaannettavia.sivu.length > 0 ? (_jsxs("section", { children: [_jsx("h2", { children: tiedot.malli.nimi }), omat.map(([avain, maaritys]) => (_jsx(Kentta_, { polku: { sivu: tiedot.sivu, kentta: avain }, maaritys: maaritys, tiedot: tiedot }, avain))), tiedot.kielet.length > 1 ? _jsx(Kaannos, { tiedot: tiedot, mihin: "sivu" }) : null] })) : null, lista ? _jsx(Kohteet, { avain: lista[0], maaritys: lista[1], tiedot: tiedot }) : null] }));
+}
+const KIELELLE = {
+    fi: "suomeksi",
+    en: "englanniksi",
+    sv: "ruotsiksi",
+};
+const KIELINEN = {
+    fi: "Suomenkielinen",
+    en: "Englanninkielinen",
+    sv: "Ruotsinkielinen",
+};
+/**
+ * Käännösehdotukset.
+ *
+ * Painike täyttää vain tyhjät kohdat, eikä koskaan kirjoita valmiin
+ * käännöksen päälle. Ehdotukset jäävät kenttiin luettaviksi — tallennus on
+ * yhä oma painalluksensa.
+ */
+function Kaannos({ tiedot, mihin }) {
+    const [tila, setTila] = useState("valmis");
+    const [viesti, setViesti] = useState("");
+    const puuttuvat = tiedot.kaannettavia[mihin];
+    if (puuttuvat.length === 0 && viesti === "")
+        return null;
+    const kielella = KIELELLE[tiedot.kieli] ?? tiedot.kieli;
+    const kieli = KIELINEN[tiedot.kieli] ?? tiedot.kieli;
+    /* Kentät nimeltä: "puuttuu yhdestä kohdasta" ei kerro, onko kyse
+       otsikosta vai koko esittelystä. */
+    const nimet = puuttuvat.slice(0, 4).join(", ");
+    const loput = puuttuvat.length - 4;
+    return (_jsxs("div", { className: "kaannos", children: [puuttuvat.length > 0 ? (_jsxs(_Fragment, { children: [_jsxs("p", { children: [kieli, " k\u00E4\u00E4nn\u00F6s puuttuu ", puuttuvat.length === 1 ? "kentästä" : "kentistä", ":", _jsxs("strong", { children: [nimet, loput > 0 ? ` ja ${loput} muuta` : ""] })] }), tiedot.kaannosKaytossa ? (_jsx("button", { type: "button", disabled: tila === "kaantaa", onClick: async () => {
+                            setTila("kaantaa");
+                            setViesti("");
+                            setViesti(await tiedot.kaanna(mihin));
+                            setTila("valmis");
+                        }, children: tila === "kaantaa" ? "Käännetään…" : `Käännä ${kielella}` })) : null] })) : null, viesti ? (_jsx("p", { className: "ohje", role: "status", children: viesti })) : null] }));
+}
+function Kohteet({ avain, maaritys, tiedot, }) {
+    if (maaritys.tyyppi !== "kohdelista")
+        return null;
+    const kohteet = Array.isArray(tiedot.data[avain])
+        ? tiedot.data[avain]
+        : [];
+    const nimi = (kohde) => {
+        const arvo = kohde[maaritys.otsikko];
+        if (typeof arvo === "string")
+            return arvo === "" ? "(nimetön)" : arvo;
+        if (!onOlio(arvo))
+            return "(nimetön)";
+        /* Nykyinen kieli ensin, mutta kääntämätön kurssi näkyy listassa sillä
+           kielellä, jolla se on kirjoitettu — ei nimettömänä. */
+        const omalla = arvo[tiedot.kieli];
+        if (typeof omalla === "string" && omalla !== "")
+            return omalla;
+        const joku = Object.values(arvo).find((muu) => typeof muu === "string" && muu !== "");
+        return joku ?? "(nimetön)";
+    };
+    /**
+     * Merkinnät kohteen nimen perässä: piilotus, huomionarvoinen tila ja
+     * täyttyminen. Näin listasta näkee tilanteen avaamatta jokaista kohdetta.
+     */
+    const merkinnat = (kohde) => {
+        const tulos = [];
+        for (const [alikentta, kenttä] of Object.entries(maaritys.kentat)) {
+            if (kenttä.tyyppi === "kytkin" && kenttä.piilottaa && kohde[alikentta] === true) {
+                tulos.push("piilossa");
+            }
+            if (kenttä.tyyppi === "valinta") {
+                const valittu = kenttä.vaihtoehdot.find((vaihtoehto) => vaihtoehto.arvo === kohde[alikentta]);
+                if (valittu?.merkitse)
+                    tulos.push(valittu.nimi.toLowerCase());
+            }
+            /* Täyttyminen lasketaan, sitä ei ole kenttänä missään. */
+            if (kenttä.tyyppi === "luku" && kenttä.enintaanKuin) {
+                const varattu = kohde[alikentta];
+                const yla = kohde[kenttä.enintaanKuin];
+                if (typeof varattu === "number" && typeof yla === "number" && yla > 0 && varattu >= yla) {
+                    tulos.push("täynnä");
+                }
+            }
+        }
+        return tulos;
+    };
+    const yksikko = maaritys.yksikko ?? "kohde";
+    const valittu = kohteet.find((kohde) => kohde[maaritys.tunnus] === tiedot.valittu);
+    const valitunTunnus = typeof valittu?.[maaritys.tunnus] === "string" ? valittu[maaritys.tunnus] : undefined;
+    const alikentat = Object.entries(maaritys.kentat).filter(([alikentta, kenttä]) => alikentta !== maaritys.tunnus &&
+        !(kenttä.tyyppi === "kielivalinta" && tiedot.kielet.length < 2) &&
+        !tiedot.sivullaNakyvat.has(`${tiedot.sivu}.${avain}[${valitunTunnus}].${alikentta}`));
+    /* Usein muuttuvat kentät esiin, kerran asetettavat taitoksen alle. */
+    const ensisijaiset = alikentat.filter(([, kenttä]) => kenttä.lisatieto !== true);
+    const lisatiedot = alikentat.filter(([, kenttä]) => kenttä.lisatieto === true);
+    const kentta = ([alikentta, kenttä]) => kenttä.tyyppi === "ryhma" ? (_jsxs("div", { className: "ryhma", children: [_jsx("h3", { children: kenttä.nimi ?? alikentta }), kenttä.ohje ? _jsx("p", { className: "ohje", children: kenttä.ohje }) : null, Object.entries(kenttä.kentat).map(([ryhmanKentta, ryhmanMaaritys]) => (_jsx(Kentta_, { polku: {
+                    sivu: tiedot.sivu,
+                    kentta: avain,
+                    tunnus: valitunTunnus,
+                    alikentta: `${alikentta}.${ryhmanKentta}`,
+                }, maaritys: ryhmanMaaritys, tiedot: tiedot }, ryhmanKentta)))] }, alikentta)) : (_jsx(Kentta_, { polku: { sivu: tiedot.sivu, kentta: avain, tunnus: valitunTunnus, alikentta }, maaritys: kenttä, tiedot: tiedot }, alikentta));
+    return (_jsxs(_Fragment, { children: [_jsxs("section", { children: [_jsx("h2", { children: maaritys.nimi ?? tiedot.malli.nimi }), _jsx("ul", { className: "kohteet", children: kohteet.map((kohde) => {
+                            const tunnus = String(kohde[maaritys.tunnus] ?? "");
+                            const omatMerkinnat = merkinnat(kohde);
+                            return (_jsx("li", { children: _jsxs("button", { type: "button", className: tunnus === valitunTunnus ? "valittu" : undefined, "aria-current": tunnus === valitunTunnus ? "true" : undefined, onClick: () => tiedot.valitse(tunnus), children: [_jsx("span", { children: nimi(kohde) }), omatMerkinnat.length > 0 ? (_jsx("span", { className: "merkki", children: omatMerkinnat.join(" · ") })) : null] }) }, tunnus));
+                        }) }), _jsx("div", { className: "napit", children: _jsxs("button", { type: "button", onClick: () => tiedot.lisaaKohde(avain, maaritys), children: ["+ Lis\u00E4\u00E4 ", yksikko] }) }), valittu ? null : (_jsxs("p", { className: "ohje", children: ["Valitse ", yksikko, ", niin n\u00E4et sen tiedot."] }))] }), valittu && valitunTunnus ? (_jsxs("section", { children: [_jsx("h2", { children: nimi(valittu) }), ensisijaiset.map(kentta), tiedot.kielet.length > 1 ? _jsx(Kaannos, { tiedot: tiedot, mihin: "kohde" }) : null, lisatiedot.length > 0 ? (_jsxs("details", { className: "lisatiedot", children: [_jsx("summary", { children: "Lis\u00E4tiedot" }), lisatiedot.map(kentta)] })) : null, _jsx("div", { className: "napit", children: _jsxs("button", { type: "button", className: "vaarallinen", onClick: () => tiedot.poistaKohde(avain, maaritys.tunnus, valitunTunnus), children: ["Poista ", yksikko] }) })] })) : null] }));
+}
+/**
+ * Kuvakenttä: nykyinen kuva, vaihto ja vaihtoehtoinen teksti.
+ *
+ * Kuva lähtee heti valittaessa, koska käsittely ja tallennus kestävät
+ * hetken — muokkaaja näkee lopputuloksen ennen kuin painaa Tallenna.
+ */
+function Kuvakentta({ maaritys, arvo, muuta, lataa, }) {
+    const [tila, setTila] = useState("valmis");
+    const [virhe, setVirhe] = useState("");
+    /* Vasta vaihdettu kuva: vanha teksti kuvaa yhä vanhaa kuvaa. */
+    const [vaihdettu, setVaihdettu] = useState(false);
+    const [ehdotus, setEhdotus] = useState(null);
+    const kuva = onOlio(arvo) ? arvo : undefined;
+    async function valitse(tiedosto) {
+        if (!tiedosto)
+            return;
+        setTila("lataa");
+        setVirhe("");
+        setEhdotus(null);
+        try {
+            const nykyinenAlt = typeof kuva?.alt === "string" ? kuva.alt.trim() : "";
+            const uusiEhdotus = await lataa(tiedosto);
+            setTila("valmis");
+            setVaihdettu(true);
+            /* Jos kentässä oli jo teksti, ehdotusta tarjotaan mutta ei tyrkytetä. */
+            if (uusiEhdotus && nykyinenAlt !== "")
+                setEhdotus(uusiEhdotus);
+        }
+        catch (syy) {
+            setTila("virhe");
+            setVirhe(syy instanceof Error ? syy.message : "Kuvan lataus ei onnistunut.");
+        }
+    }
+    return (_jsxs("div", { className: "kuva", children: [typeof kuva?.src === "string" ? (_jsx("img", { src: kuva.src, alt: "" })) : (_jsx("p", { className: "tyhja", children: "Ei kuvaa." })), _jsxs("label", { className: "lataus", children: [_jsx("span", { children: tila === "lataa" ? "Käsitellään…" : "Vaihda kuva" }), _jsx("input", { type: "file", accept: "image/*", disabled: tila === "lataa", onChange: (tapahtuma) => valitse(tapahtuma.target.files?.[0]) })] }), tila === "virhe" ? _jsx("p", { className: "virheviesti", children: virhe }) : null, _jsxs("label", { className: "alt", children: ["Kuvan kuvaus", _jsx("input", { type: "text", placeholder: "Esimerkiksi: kynttil\u00E4 ikkunalaudalla", value: typeof kuva?.alt === "string" ? kuva.alt : "", onChange: (tapahtuma) => {
+                            setVaihdettu(false);
+                            muuta({ ...(kuva ?? {}), alt: tapahtuma.target.value });
+                        } })] }), ehdotus ? (_jsxs("div", { className: "huomio", role: "status", children: [_jsxs("p", { children: ["Ehdotus: \u201C", ehdotus, "\u201D"] }), _jsx("button", { type: "button", onClick: () => {
+                            muuta({ ...(kuva ?? {}), alt: ehdotus });
+                            setEhdotus(null);
+                            setVaihdettu(false);
+                        }, children: "K\u00E4yt\u00E4" })] })) : vaihdettu ? (_jsx("p", { className: "huomio", role: "status", children: "Tarkista kuvan kuvaus." })) : null, maaritys.pakollinenAlt === false ? null : (_jsx("p", { className: "ohje", children: "N\u00E4kyy vain, jos kuva ei lataudu. Ruudunlukija lukee sen \u00E4\u00E4neen. (alt-teksti)" }))] }));
+}
+export { asetaArvo };

package/dist/selain/index.d.ts

@@ -0,0 +1,4 @@
+export { EditorinPalkki } from "./EditorinPalkki.tsx";
+export { PalkkiLataaja } from "./PalkkiLataaja.tsx";
+export { Muokkaustila } from "./Muokkaustila.tsx";
+export { valitseKieli } from "./kieli.ts";

package/dist/selain/index.js

@@ -0,0 +1,8 @@
+/*
+  Studio Editori — selainosa. Nämä ovat asiakaskomponentteja ("use client"),
+  ja ne ladataan vain kirjautuneelle muokkaajalle.
+*/
+export { EditorinPalkki } from "./EditorinPalkki.js";
+export { PalkkiLataaja } from "./PalkkiLataaja.js";
+export { Muokkaustila } from "./Muokkaustila.js";
+export { valitseKieli } from "./kieli.js";

package/dist/selain/kieli.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Sivun `lang`-määreestä sivuston kieleksi.
+ *
+ * Omassa tiedostossaan (ilman JSX:ää), jotta sen voi testata suoraan
+ * Nodella ilman selainta tai käännösvaihetta.
+ *
+ * Tuntematon kieli olisi uusi kenttä sisältötiedostoon, ja palvelin hylkäisi
+ * sen — turvallisempi on tallentaa oletuskielelle kuin kadottaa teksti.
+ */
+export declare function valitseKieli(lang: string | null | undefined, kielet: string[]): string;

package/dist/selain/kieli.js

@@ -0,0 +1,14 @@
+/**
+ * Sivun `lang`-määreestä sivuston kieleksi.
+ *
+ * Omassa tiedostossaan (ilman JSX:ää), jotta sen voi testata suoraan
+ * Nodella ilman selainta tai käännösvaihetta.
+ *
+ * Tuntematon kieli olisi uusi kenttä sisältötiedostoon, ja palvelin hylkäisi
+ * sen — turvallisempi on tallentaa oletuskielelle kuin kadottaa teksti.
+ */
+export function valitseKieli(lang, kielet) {
+    const oletus = kielet[0] ?? "fi";
+    const arvo = (lang ?? "").trim().toLowerCase().split("-")[0];
+    return arvo && kielet.includes(arvo) ? arvo : oletus;
+}

package/dist/selain/kuva.d.ts

@@ -0,0 +1,7 @@
+export interface Pienennys {
+    /** Kuva base64-muodossa ilman data-etuliitettä. */
+    tavut: string;
+    leveys: number;
+    korkeus: number;
+}
+export declare function pienennaKuva(tiedosto: File, pisinSivu?: number): Promise<Pienennys>;

package/dist/selain/kuva.js

@@ -0,0 +1,45 @@
+/* ==========================================================================
+   KUVA SELAIMESSA
+   ==========================================================================
+   Kuva piirretään uudelleen ennen lähetystä. Sillä on kolme tarkoitusta:
+
+   1. Kameran kuva on kymmeniä megatavuja — se ei mene palvelimelle
+      sellaisenaan.
+   2. Uudelleenpiirto pudottaa metatiedot, myös kuvauspaikan sijainnin.
+   3. Palvelimelle ei päädy alkuperäistä tiedostoa lainkaan, joten
+      kuvankäsittelykirjastojen aukot eivät ole samalla tavalla alttiina.
+   ========================================================================== */
+const PISIN_SIVU = 2560;
+export async function pienennaKuva(tiedosto, pisinSivu = PISIN_SIVU) {
+    const kuva = await lueKuva(tiedosto);
+    const suurin = Math.max(kuva.width, kuva.height);
+    const kerroin = suurin > pisinSivu ? pisinSivu / suurin : 1;
+    const leveys = Math.round(kuva.width * kerroin);
+    const korkeus = Math.round(kuva.height * kerroin);
+    const kangas = document.createElement("canvas");
+    kangas.width = leveys;
+    kangas.height = korkeus;
+    const piirtaja = kangas.getContext("2d");
+    if (!piirtaja)
+        throw new Error("Selain ei osannut käsitellä kuvaa.");
+    piirtaja.drawImage(kuva, 0, 0, leveys, korkeus);
+    /* JPEG eikä PNG: valokuvista tulisi PNG:nä moninkertaisia. Palvelin
+       muuntaa lopullisen muodon joka tapauksessa. */
+    const data = kangas.toDataURL("image/jpeg", 0.9);
+    return { tavut: data.split(",")[1] ?? "", leveys, korkeus };
+}
+function lueKuva(tiedosto) {
+    return new Promise((valmis, virhe) => {
+        const osoite = URL.createObjectURL(tiedosto);
+        const kuva = new Image();
+        kuva.onload = () => {
+            URL.revokeObjectURL(osoite);
+            valmis(kuva);
+        };
+        kuva.onerror = () => {
+            URL.revokeObjectURL(osoite);
+            virhe(new Error("Kuvaa ei voitu avata. Kokeile toista tiedostoa."));
+        };
+        kuva.src = osoite;
+    });
+}

package/dist/selain/polku.d.ts

@@ -0,0 +1,21 @@
+export interface Kentanpolku {
+    sivu: string;
+    kentta: string;
+    /** Kohteen tunnus, jos kenttä on listan sisällä. */
+    tunnus?: string;
+    /** Kentän nimi kohteen sisällä. */
+    alikentta?: string;
+}
+export declare function lueKentanpolku(polku: string): Kentanpolku | null;
+export declare function kirjoitaKentanpolku(polku: Kentanpolku): string;
+/**
+ * Kirjoittaa yhden arvon sivun sisältöön ja palauttaa uuden sisällön.
+ *
+ * Alkuperäistä ei muuteta: muokkaus voi epäonnistua tai perua, eikä silloin
+ * saa jäädä puolikasta tilaa. `kieli` annetaan vain käännettäville kentille.
+ */
+export declare function asetaArvo(sivunData: Record<string, unknown>, polku: Kentanpolku, arvo: unknown, kieli?: string, tunnusKentta?: string): Record<string, unknown>;
+/** Lukee yhden arvon sivun sisällöstä. */
+export declare function lueArvo(sivunData: Record<string, unknown>, polku: Kentanpolku, tunnusKentta?: string): unknown;
+/** Tunnus, joka ei ole vielä käytössä. Uusi kohde saa sen pohjaksi. */
+export declare function vapaaTunnus(kaytossa: readonly string[], ehdotus: string): string;

package/dist/selain/polku.js

@@ -0,0 +1,108 @@
+/* ==========================================================================
+   KENTTIEN POLUT
+   ==========================================================================
+   Sivulla oleva merkintä kertoo, mitä kohtaa sisällöstä elementti näyttää:
+
+     kurssit.otsikko                      sivun oma kenttä
+     kurssit.lista[joogaretriitti].nimi   yhden kohteen kenttä listassa
+
+   Hakasulkeissa on kohteen tunnus, ei järjestysnumero. Näin muokkaus osuu
+   oikeaan kurssiin, vaikka järjestys muuttuisi tai joku lisäisi kurssin
+   samaan aikaan.
+
+   Tämä tiedosto on tarkoituksella pelkkää logiikkaa ilman selainta, jotta
+   sen voi testata suoraan.
+   ========================================================================== */
+/* Alikenttä voi olla ryhmän sisällä: "kurssit.lista[tunnus].meta.title". */
+const MUOTO = /^([a-zA-Z][a-zA-Z0-9]*)\.([a-zA-Z][a-zA-Z0-9]*)(?:\[([^\]]+)\]\.([a-zA-Z][a-zA-Z0-9]*(?:\.[a-zA-Z][a-zA-Z0-9]*)?))?$/;
+export function lueKentanpolku(polku) {
+    const osuma = MUOTO.exec(polku.trim());
+    if (!osuma)
+        return null;
+    const [, sivu, kentta, tunnus, alikentta] = osuma;
+    if (!sivu || !kentta)
+        return null;
+    if (tunnus !== undefined && !alikentta)
+        return null;
+    return tunnus === undefined ? { sivu, kentta } : { sivu, kentta, tunnus, alikentta };
+}
+export function kirjoitaKentanpolku(polku) {
+    return polku.tunnus === undefined
+        ? `${polku.sivu}.${polku.kentta}`
+        : `${polku.sivu}.${polku.kentta}[${polku.tunnus}].${polku.alikentta}`;
+}
+/* ---- Arvon asettaminen --------------------------------------------------- */
+function onOlio(arvo) {
+    return typeof arvo === "object" && arvo !== null && !Array.isArray(arvo);
+}
+/**
+ * Kirjoittaa yhden arvon sivun sisältöön ja palauttaa uuden sisällön.
+ *
+ * Alkuperäistä ei muuteta: muokkaus voi epäonnistua tai perua, eikä silloin
+ * saa jäädä puolikasta tilaa. `kieli` annetaan vain käännettäville kentille.
+ */
+export function asetaArvo(sivunData, polku, arvo, kieli, tunnusKentta = "tunnus") {
+    const yhdista = (vanha) => {
+        if (!kieli)
+            return arvo;
+        const pohja = onOlio(vanha) ? vanha : {};
+        return { ...pohja, [kieli]: arvo };
+    };
+    if (polku.tunnus === undefined) {
+        return { ...sivunData, [polku.kentta]: yhdista(sivunData[polku.kentta]) };
+    }
+    const lista = Array.isArray(sivunData[polku.kentta]) ? [...sivunData[polku.kentta]] : [];
+    const sija = lista.findIndex((kohde) => onOlio(kohde) && kohde[tunnusKentta] === polku.tunnus);
+    if (sija === -1)
+        return sivunData;
+    const kohde = lista[sija];
+    const [ensimmainen, ryhmanKentta] = polku.alikentta.split(".");
+    const avain = ensimmainen;
+    if (ryhmanKentta === undefined) {
+        lista[sija] = { ...kohde, [avain]: yhdista(kohde[avain]) };
+    }
+    else {
+        /* Ryhmän sisällä oleva kenttä: muu ryhmä säilyy ennallaan. */
+        const ryhma = onOlio(kohde[avain]) ? kohde[avain] : {};
+        lista[sija] = {
+            ...kohde,
+            [avain]: { ...ryhma, [ryhmanKentta]: yhdista(ryhma[ryhmanKentta]) },
+        };
+    }
+    return { ...sivunData, [polku.kentta]: lista };
+}
+/** Lukee yhden arvon sivun sisällöstä. */
+export function lueArvo(sivunData, polku, tunnusKentta = "tunnus") {
+    if (polku.tunnus === undefined)
+        return sivunData[polku.kentta];
+    const lista = sivunData[polku.kentta];
+    if (!Array.isArray(lista))
+        return undefined;
+    const kohde = lista.find((osa) => onOlio(osa) && osa[tunnusKentta] === polku.tunnus);
+    if (!onOlio(kohde))
+        return undefined;
+    const [ensimmainen, ryhmanKentta] = polku.alikentta.split(".");
+    const arvo = kohde[ensimmainen];
+    if (ryhmanKentta === undefined)
+        return arvo;
+    return onOlio(arvo) ? arvo[ryhmanKentta] : undefined;
+}
+/** Tunnus, joka ei ole vielä käytössä. Uusi kohde saa sen pohjaksi. */
+export function vapaaTunnus(kaytossa, ehdotus) {
+    const siisti = ehdotus
+        .toLowerCase()
+        .replaceAll("ä", "a")
+        .replaceAll("ö", "o")
+        .replaceAll("å", "a")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 60) || "uusi";
+    if (!kaytossa.includes(siisti))
+        return siisti;
+    for (let numero = 2; numero < 1000; numero++) {
+        const kokeilu = `${siisti}-${numero}`;
+        if (!kaytossa.includes(kokeilu))
+            return kokeilu;
+    }
+    return `${siisti}-${Date.now()}`;
+}

package/dist/selain/tyypit.d.ts

@@ -0,0 +1,22 @@
+import type { Kentta } from "../maarittely.ts";
+export interface SivunMalli {
+    nimi: string;
+    kentat: Record<string, Kentta>;
+}
+export interface Sisalto {
+    versio: string;
+    muokkaaja: string;
+    /** Sivun avain → sivun sisältö sellaisena kuin se on tiedostossa. */
+    sivut: Record<string, Record<string, unknown>>;
+    /** Sivun avain → sen tiedoston versio, josta muokkaus alkoi. */
+    versiot: Record<string, string>;
+    /** Sivuston kielet, ensimmäinen on oletuskieli. */
+    kielet: string[];
+    /** Sivun avain → mitä sivulla saa muokata. */
+    malli: Record<string, SivunMalli>;
+    /** Valinnaiset ominaisuudet, jotka vaativat oman avaimensa. */
+    ominaisuudet?: {
+        kuvateksti: boolean;
+        kaannos: boolean;
+    };
+}

package/dist/selain/tyypit.js

@@ -0,0 +1,2 @@
+/* Selainpuolen yhteiset tyypit. */
+export {};

package/dist/tarkistus.d.ts

@@ -0,0 +1,26 @@
+import type { SisallonMaarittely, Sivu, SivunMaarittely } from "./maarittely.ts";
+export interface Huomio {
+    /** Kentän polku, esim. "etusivu.avauskysymys", tai sivu, jos koskee koko sivua. */
+    kohde: string;
+    /** Kieli, jos huomio koskee yhtä kieliversiota. */
+    kieli?: string;
+    viesti: string;
+}
+export interface Tarkistustulos {
+    virheet: Huomio[];
+    varoitukset: Huomio[];
+}
+/** Merkkien määrä niin kuin lukija ne näkee (esim. "é" tai emoji = 1). */
+export declare function merkkimaara(teksti: string): number;
+/**
+ * Tarkistaa yhden sivun sisällön sisältömallia vasten. `data` on mitä
+ * tahansa, esimerkiksi selaimelta tullut tallennuspyyntö, joten mitään ei
+ * oleteta etukäteen.
+ */
+export declare function tarkistaSivu(maarittely: SisallonMaarittely, sivunAvain: string, data: unknown): Tarkistustulos;
+/**
+ * Muuntaa tallennetun sivun yhdelle kielelle. Puuttuva käännös korvataan
+ * oletuskielellä: vieraskielinen rivi on julkisella sivulla parempi kuin
+ * tyhjä kohta, ja editori näyttää puuttuvat käännökset muokkaajalle.
+ */
+export declare function kielista<S extends SivunMaarittely>(maarittely: SisallonMaarittely, sivu: S, data: Record<string, unknown>, kieli: string): Sivu<S>;