@studiotitta/studio-editori 0.1.0

package/dist/tarkistus.js

@@ -0,0 +1,324 @@
+const segmentoija = new Intl.Segmenter("fi", { granularity: "grapheme" });
+/** Merkkien määrä niin kuin lukija ne näkee (esim. "é" tai emoji = 1). */
+export function merkkimaara(teksti) {
+    let maara = 0;
+    for (const _ of segmentoija.segment(teksti))
+        maara++;
+    return maara;
+}
+function onTavallinenOlio(arvo) {
+    return typeof arvo === "object" && arvo !== null && !Array.isArray(arvo);
+}
+function onTyhja(arvo) {
+    if (arvo === undefined || arvo === null)
+        return true;
+    if (typeof arvo === "string")
+        return arvo.trim() === "";
+    if (Array.isArray(arvo))
+        return arvo.length === 0;
+    return false;
+}
+/** Onko kenttä sellainen, jonka arvo tallennetaan kielittäin? */
+function onKaannettava(maaritys) {
+    return "kaannettava" in maaritys && maaritys.kaannettava === true;
+}
+/* ---- Yksittäiset tyypit -------------------------------------------------- */
+function tarkistaTeksti(teksti, maaritys, kohde, kieli, tulos) {
+    const huomio = (viesti) => (kieli ? { kohde, kieli, viesti } : { kohde, viesti });
+    if (typeof teksti !== "string") {
+        tulos.virheet.push(huomio("Arvon pitää olla tekstiä."));
+        return;
+    }
+    if (maaritys.tyyppi === "teksti" && /[\r\n]/.test(teksti)) {
+        tulos.virheet.push(huomio("Tähän kenttään ei voi lisätä rivinvaihtoa."));
+    }
+    if (maaritys.pakollinen && teksti.trim() === "") {
+        tulos.virheet.push(huomio("Kenttä ei voi olla tyhjä."));
+    }
+    const suositus = "suositusPituus" in maaritys ? maaritys.suositusPituus : undefined;
+    if (suositus !== undefined) {
+        const yli = merkkimaara(teksti) - suositus;
+        if (yli > 0) {
+            tulos.varoitukset.push(huomio(`Teksti on ${yli} merkkiä pidempi kuin suunniteltu. Tarkista, miltä se näyttää puhelimella.`));
+        }
+    }
+}
+function tarkistaTekstilista(arvo, maaritys, kohde, kieli, tulos) {
+    const huomio = (viesti) => (kieli ? { kohde, kieli, viesti } : { kohde, viesti });
+    if (!Array.isArray(arvo)) {
+        tulos.virheet.push(huomio("Arvon pitää olla lista tekstejä."));
+        return;
+    }
+    if (maaritys.enintaan !== undefined && arvo.length > maaritys.enintaan) {
+        tulos.virheet.push(huomio(`Listassa voi olla enintään ${maaritys.enintaan} kohtaa.`));
+    }
+    if (maaritys.pakollinen && arvo.length === 0) {
+        tulos.virheet.push(huomio("Kenttä ei voi olla tyhjä."));
+    }
+    arvo.forEach((kohta, sija) => {
+        if (typeof kohta !== "string") {
+            tulos.virheet.push(huomio(`Kohta ${sija + 1} ei ole tekstiä.`));
+            return;
+        }
+        if (!maaritys.monirivinen && /[\r\n]/.test(kohta)) {
+            tulos.virheet.push(huomio(`Kohtaan ${sija + 1} ei voi lisätä rivinvaihtoa.`));
+        }
+    });
+}
+function tarkistaLuku(arvo, maaritys, kohde, sisarukset, tulos) {
+    if (typeof arvo !== "number" || !Number.isFinite(arvo)) {
+        tulos.virheet.push({ kohde, viesti: "Arvon pitää olla luku." });
+        return;
+    }
+    if (!Number.isInteger(arvo)) {
+        tulos.virheet.push({ kohde, viesti: "Luvun pitää olla kokonaisluku." });
+        return;
+    }
+    if (maaritys.pienin !== undefined && arvo < maaritys.pienin) {
+        tulos.virheet.push({ kohde, viesti: `Luku ei voi olla pienempi kuin ${maaritys.pienin}.` });
+    }
+    if (maaritys.suurin !== undefined && arvo > maaritys.suurin) {
+        tulos.virheet.push({ kohde, viesti: `Luku ei voi olla suurempi kuin ${maaritys.suurin}.` });
+    }
+    /* Vertailu toiseen kenttään: varatut paikat eivät voi ylittää ryhmäkokoa. */
+    if (maaritys.enintaanKuin) {
+        const raja = sisarukset[maaritys.enintaanKuin];
+        if (typeof raja === "number" && arvo > raja) {
+            tulos.virheet.push({
+                kohde,
+                viesti: `Luku ei voi olla suurempi kuin ${raja}.`,
+            });
+        }
+    }
+}
+function tarkistaKuva(arvo, maaritys, kohde, tulos) {
+    if (!onTavallinenOlio(arvo)) {
+        tulos.virheet.push({ kohde, viesti: "Kuvan arvo on väärässä muodossa." });
+        return;
+    }
+    const { src, alt } = arvo;
+    if (typeof src !== "string" || src === "") {
+        tulos.virheet.push({ kohde, viesti: "Kuvatiedosto puuttuu." });
+    }
+    else if (!src.startsWith("/") || src.includes("..")) {
+        /* Osoite tulee kuvien latauksesta; tämä estää sen, että käsin muokattu
+           tiedosto voisi osoittaa sivuston ulkopuolelle. */
+        tulos.virheet.push({ kohde, viesti: "Kuvan osoite ei kelpaa." });
+    }
+    if (typeof alt !== "string") {
+        tulos.virheet.push({ kohde, viesti: "Kuvan vaihtoehtoinen teksti on väärässä muodossa." });
+    }
+    else if (maaritys.pakollinenAlt !== false && alt.trim() === "") {
+        tulos.virheet.push({
+            kohde,
+            viesti: "Kerro sanoin, mitä kuvassa on. Sen lukee se, joka ei näe kuvaa.",
+        });
+    }
+}
+/* ---- Kentät ja kohteet --------------------------------------------------- */
+function tarkistaKentta(kielet, maaritys, arvo, kohde, sisarukset, tulos) {
+    /* null on sama kuin tyhjä: sisältötiedostoissa sillä merkitään "ei vielä
+       tiedossa" (esimerkiksi maksulinkki, jota ei ole avattu). */
+    if (arvo === undefined || arvo === null) {
+        if (maaritys.pakollinen)
+            tulos.virheet.push({ kohde, viesti: "Kenttä ei voi olla tyhjä." });
+        return;
+    }
+    if (onKaannettava(maaritys)) {
+        if (!onTavallinenOlio(arvo)) {
+            tulos.virheet.push({ kohde, viesti: "Käännettävän kentän arvo on väärässä muodossa." });
+            return;
+        }
+        for (const kieli of Object.keys(arvo)) {
+            if (!kielet.includes(kieli)) {
+                tulos.virheet.push({ kohde, kieli, viesti: `Sivustolla ei ole kieltä "${kieli}".` });
+            }
+        }
+        const oletuskieli = kielet[0];
+        for (const kieli of kielet) {
+            const kaannos = arvo[kieli];
+            if (onTyhja(kaannos)) {
+                /*
+                  Pakollinen kenttä vaaditaan vain oletuskielellä. Keskeneräinen
+                  käännös ei saa estää julkaisua: uusi kurssi kirjoitetaan ensin
+                  suomeksi, ja englanti tulee perässä. Puuttuva käännös näkyy
+                  varoituksena, jotta se ei myöskään unohdu.
+                */
+                if (maaritys.pakollinen && kieli === oletuskieli) {
+                    tulos.virheet.push({ kohde, kieli, viesti: "Kenttä ei voi olla tyhjä." });
+                }
+                else if (maaritys.pakollinen || Object.values(arvo).some((muu) => !onTyhja(muu))) {
+                    tulos.varoitukset.push({ kohde, kieli, viesti: "Käännös puuttuu." });
+                }
+                continue;
+            }
+            if (maaritys.tyyppi === "tekstilista") {
+                tarkistaTekstilista(kaannos, maaritys, kohde, kieli, tulos);
+            }
+            else {
+                tarkistaTeksti(kaannos, maaritys, kohde, kieli, tulos);
+            }
+        }
+        return;
+    }
+    switch (maaritys.tyyppi) {
+        case "teksti":
+        case "tekstialue":
+            tarkistaTeksti(arvo, maaritys, kohde, undefined, tulos);
+            return;
+        case "tekstilista":
+            tarkistaTekstilista(arvo, maaritys, kohde, undefined, tulos);
+            return;
+        case "luku":
+            tarkistaLuku(arvo, maaritys, kohde, sisarukset, tulos);
+            return;
+        case "valinta":
+            if (typeof arvo !== "string" || !maaritys.vaihtoehdot.some((v) => v.arvo === arvo)) {
+                const sallitut = maaritys.vaihtoehdot.map((v) => v.arvo).join(", ");
+                tulos.virheet.push({ kohde, viesti: `Arvon pitää olla jokin näistä: ${sallitut}.` });
+            }
+            return;
+        case "kytkin":
+            if (typeof arvo !== "boolean") {
+                tulos.virheet.push({ kohde, viesti: "Arvon pitää olla kyllä tai ei." });
+            }
+            return;
+        case "aika":
+            if (typeof arvo !== "string" || Number.isNaN(new Date(arvo).getTime())) {
+                tulos.virheet.push({ kohde, viesti: "Aika ei kelpaa." });
+            }
+            return;
+        case "kuva":
+            tarkistaKuva(arvo, maaritys, kohde, tulos);
+            return;
+        case "kielivalinta": {
+            if (!Array.isArray(arvo)) {
+                tulos.virheet.push({ kohde, viesti: "Arvon pitää olla lista kieliä." });
+                return;
+            }
+            for (const kieli of arvo) {
+                if (typeof kieli !== "string" || !kielet.includes(kieli)) {
+                    tulos.virheet.push({ kohde, viesti: `Sivustolla ei ole kieltä "${String(kieli)}".` });
+                }
+            }
+            if (new Set(arvo).size !== arvo.length) {
+                tulos.virheet.push({ kohde, viesti: "Sama kieli on valittu kahdesti." });
+            }
+            if (maaritys.pakollinen && arvo.length === 0) {
+                tulos.virheet.push({ kohde, viesti: "Valitse vähintään yksi kieli." });
+            }
+            return;
+        }
+        case "ryhma": {
+            if (!onTavallinenOlio(arvo)) {
+                tulos.virheet.push({ kohde, viesti: "Arvon pitää olla ryhmä kenttiä." });
+                return;
+            }
+            tarkistaJoukko(kielet, maaritys.kentat, arvo, kohde, tulos);
+            return;
+        }
+        case "kohdelista": {
+            if (!Array.isArray(arvo)) {
+                tulos.virheet.push({ kohde, viesti: "Arvon pitää olla lista." });
+                return;
+            }
+            const tunnukset = new Set();
+            arvo.forEach((kohta, sija) => {
+                if (!onTavallinenOlio(kohta)) {
+                    tulos.virheet.push({ kohde: `${kohde}[${sija + 1}]`, viesti: "Kohde on väärässä muodossa." });
+                    return;
+                }
+                const tunnus = kohta[maaritys.tunnus];
+                const nimi = typeof tunnus === "string" && tunnus !== "" ? tunnus : `${sija + 1}`;
+                if (typeof tunnus === "string" && tunnus !== "") {
+                    if (tunnukset.has(tunnus)) {
+                        tulos.virheet.push({
+                            kohde: `${kohde}.${nimi}`,
+                            viesti: `Tunnus "${tunnus}" on jo toisella kohteella.`,
+                        });
+                    }
+                    tunnukset.add(tunnus);
+                }
+                tarkistaJoukko(kielet, maaritys.kentat, kohta, `${kohde}.${nimi}`, tulos);
+            });
+            return;
+        }
+    }
+}
+function tarkistaJoukko(kielet, kentat, data, polku, tulos) {
+    for (const avain of Object.keys(data)) {
+        if (!Object.hasOwn(kentat, avain)) {
+            tulos.virheet.push({ kohde: `${polku}.${avain}`, viesti: "Tätä kenttää ei ole sisältömallissa." });
+        }
+    }
+    for (const [avain, maaritys] of Object.entries(kentat)) {
+        tarkistaKentta(kielet, maaritys, data[avain], `${polku}.${avain}`, data, tulos);
+    }
+}
+/**
+ * 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 function tarkistaSivu(maarittely, sivunAvain, data) {
+    const tulos = { virheet: [], varoitukset: [] };
+    const sivu = maarittely.sivut[sivunAvain];
+    if (!sivu) {
+        tulos.virheet.push({ kohde: sivunAvain, viesti: "Tuntematon sivu." });
+        return tulos;
+    }
+    if (!onTavallinenOlio(data)) {
+        tulos.virheet.push({ kohde: sivunAvain, viesti: "Sivun sisältö on väärässä muodossa." });
+        return tulos;
+    }
+    tarkistaJoukko(maarittely.kielet, sivu.kentat, data, sivunAvain, tulos);
+    return tulos;
+}
+/* ---- Kielistys ----------------------------------------------------------- */
+function kielistaArvo(maaritys, arvo, kielet, kieli) {
+    const oletuskieli = kielet[0] ?? kieli;
+    if (onKaannettava(maaritys)) {
+        const kaannokset = onTavallinenOlio(arvo) ? arvo : {};
+        const omalla = kaannokset[kieli];
+        const oletuksella = kaannokset[oletuskieli];
+        const valittu = !onTyhja(omalla) ? omalla : oletuksella;
+        if (maaritys.tyyppi === "tekstilista")
+            return Array.isArray(valittu) ? valittu : [];
+        return typeof valittu === "string" ? valittu : "";
+    }
+    switch (maaritys.tyyppi) {
+        case "teksti":
+        case "tekstialue":
+            return typeof arvo === "string" ? arvo : "";
+        case "tekstilista":
+        case "kielivalinta":
+            return Array.isArray(arvo) ? arvo : [];
+        case "kytkin":
+            return arvo === true;
+        case "ryhma":
+            return kielistaJoukko(maaritys.kentat, onTavallinenOlio(arvo) ? arvo : {}, kielet, kieli);
+        case "kohdelista":
+            return Array.isArray(arvo)
+                ? arvo
+                    .filter(onTavallinenOlio)
+                    .map((kohta) => kielistaJoukko(maaritys.kentat, kohta, kielet, kieli))
+                : [];
+        default:
+            return arvo;
+    }
+}
+function kielistaJoukko(kentat, data, kielet, kieli) {
+    const tulos = {};
+    for (const [avain, maaritys] of Object.entries(kentat)) {
+        tulos[avain] = kielistaArvo(maaritys, data[avain], kielet, kieli);
+    }
+    return tulos;
+}
+/**
+ * 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 function kielista(maarittely, sivu, data, kieli) {
+    return kielistaJoukko(sivu.kentat, data, maarittely.kielet, kieli);
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@studiotitta/studio-editori",
+  "version": "0.1.0",
+  "description": "Studio Titan sisältöeditori asiakassivustoille: tekstit ja kuvat muokataan suoraan sivulla",
+  "license": "UNLICENSED",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./palvelin": {
+      "types": "./dist/palvelin/index.d.ts",
+      "default": "./dist/palvelin/index.js"
+    },
+    "./komponentit": {
+      "types": "./dist/komponentit/index.d.ts",
+      "default": "./dist/komponentit/index.js"
+    },
+    "./selain": {
+      "types": "./dist/selain/index.d.ts",
+      "default": "./dist/selain/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "tarkista": "tsc --noEmit",
+    "testit": "node --test \"testit/*.test.ts\"",
+    "prepublishOnly": "npm run tarkista && npm run testit && npm run build"
+  },
+  "peerDependencies": {
+    "next": ">=16.3.3",
+    "react": ">=19.0.0",
+    "react-dom": ">=19.0.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TittaWin/studio-editori.git"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.6",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "next": "^16.3.6",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "typescript": "^7.0.2"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.70.0"
+  }
+}