@lupinum/ginko 0.4.0 → 0.6.0

package/dist/basics.mjs

@@ -0,0 +1,416 @@
+import { f, O as studioLabel } from './shared/ginko.BNVC-g9n.mjs';
+import { s as single, c as collection } from './shared/ginko.C-oz8wwI.mjs';
+export { h as withoutFiles } from './shared/ginko.C-oz8wwI.mjs';
+import { o as organizationLd, c as compact, a as articleLd, p as postalAddressLd, d as faqLd } from './shared/ginko.DCHGkQ7P.mjs';
+import { s as sourceOf, w as weekFor, a as addDays, h as hoursOn, b as weekdayOf, c as spansOf, d as weekdayKeys, e as both } from './shared/ginko.WAfoMhv1.mjs';
+export { f as austrianHolidays, g as calendarIn, i as calendarOf, j as closedOnClosure, k as eventJsonLd, l as events, m as germanHolidays, n as holidayOn, o as hourPlans, p as hours, q as hoursLine, r as notices, t as noticesOn, u as offerJsonLd, v as planOn, x as sessions, y as sessionsInOrder, z as singaporeHolidays, A as spansText, B as timesOf, C as todayState, D as upcomingClosures, E as upcomingHolidayClosures, F as upcomingPlans, G as weekOf } from './shared/ginko.WAfoMhv1.mjs';
+import { l as limitOf } from './shared/ginko.D1PeQ3ds.mjs';
+export { c as calendarOfCountry } from './shared/ginko.D1PeQ3ds.mjs';
+import 'comark';
+import 'comark/plugins/alert';
+import 'comark/plugins/attributes';
+import 'comark/plugins/components';
+import 'comark/plugins/emoji';
+import 'comark/plugins/footnotes';
+import 'comark/plugins/frontmatter';
+import 'comark/plugins/math';
+import 'comark/plugins/mermaid';
+import 'comark/plugins/task-list';
+import 'comark/plugins/toc';
+import '@lupinum/ginko-i18n/core';
+
+function site(o = {}) {
+  const plain = { optional: true, translate: false };
+  const fields = {
+    legalName: f.text(studioLabel("Offizieller Name", "Legal name", "Nombre legal", "Raison sociale"), {
+      ...plain,
+      hint: studioLabel("Wie im Register eingetragen.", "As registered.", "Tal como figura en el registro.", "Tel qu\u2019enregistr\xE9.")
+    }),
+    street: f.text(studioLabel("Stra\xDFe und Hausnummer", "Street and number", "Calle y n\xFAmero", "Rue et num\xE9ro"), plain),
+    postalCode: f.text(studioLabel("Postleitzahl", "Postcode", "C\xF3digo postal", "Code postal"), { ...plain, max: 10 }),
+    city: f.text(studioLabel("Ort", "Town or city", "Localidad", "Ville"), plain),
+    email: f.text(studioLabel("E-Mail", "Email", "Correo electr\xF3nico", "E-mail"), { optional: true, format: "email" }),
+    phone: f.text(studioLabel("Telefon", "Phone", "Tel\xE9fono", "T\xE9l\xE9phone"), {
+      optional: true,
+      format: "tel",
+      hint: studioLabel("Mit L\xE4ndervorwahl.", "With country code.", "Con prefijo internacional.", "Avec l\u2019indicatif du pays.")
+    }),
+    registryNumber: f.text(studioLabel("Registernummer", "Registration number", "N\xFAmero de registro", "Num\xE9ro d\u2019immatriculation"), plain),
+    registryCourt: f.text(studioLabel("Registergericht", "Registry", "Registro", "Greffe"), { optional: true }),
+    vatId: f.text(studioLabel("Umsatzsteuer-ID", "VAT number", "NIF-IVA", "Num\xE9ro de TVA"), plain)
+  };
+  return single({
+    label: o.label ?? studioLabel("Kontakt und Anschrift", "Contact and address", "Contacto y direcci\xF3n", "Contact et adresse"),
+    describe: studioLabel(
+      "Name, Anschrift und Kontakt, zum Beispiel f\xFCr das Impressum und die Fu\xDFzeile.",
+      "Name, address and contact details, for example for the imprint and the footer.",
+      "Nombre, direcci\xF3n y datos de contacto, por ejemplo para el aviso legal y el pie de p\xE1gina.",
+      "Nom, adresse et coordonn\xE9es, par exemple pour les mentions l\xE9gales et le pied de page."
+    ),
+    ...sourceOf(o),
+    fields,
+    tasks: [{
+      id: "edit",
+      kind: "edit",
+      label: studioLabel("Kontaktdaten \xE4ndern", "Change contact details", "Cambiar los datos de contacto", "Modifier les coordonn\xE9es"),
+      fields: Object.keys(fields)
+    }]
+  });
+}
+function siteJsonLd(data, o) {
+  return organizationLd({
+    ...o,
+    legalName: data.legalName,
+    email: data.email,
+    telephone: data.phone,
+    address: { street: data.street, postalCode: data.postalCode, city: data.city, country: o.country },
+    vatID: data.vatId
+  });
+}
+
+const legalTypes = [
+  { value: "privacy", label: studioLabel("Datenschutz", "Privacy policy", "Pol\xEDtica de privacidad", "Politique de confidentialit\xE9") },
+  { value: "customer-privacy", label: studioLabel("Datenschutz f\xFCr Kunden", "Privacy policy for customers", "Privacidad para clientes", "Confidentialit\xE9 pour les clients") },
+  { value: "imprint", label: studioLabel("Impressum", "Imprint", "Aviso legal", "Mentions l\xE9gales") },
+  { value: "terms", label: studioLabel("AGB", "Terms and conditions", "T\xE9rminos y condiciones", "Conditions g\xE9n\xE9rales") },
+  { value: "cookies", label: studioLabel("Cookies", "Cookie policy", "Pol\xEDtica de cookies", "Politique relative aux cookies") },
+  { value: "accessibility", label: studioLabel("Barrierefreiheit", "Accessibility statement", "Declaraci\xF3n de accesibilidad", "D\xE9claration d\u2019accessibilit\xE9") }
+];
+function legal(o = {}) {
+  return collection({
+    label: o.label ?? studioLabel("Rechtliches", "Legal", "Textos legales", "Informations l\xE9gales"),
+    ...sourceOf(o),
+    max: 20,
+    order: "manual",
+    ...o.route ? { route: o.route } : {},
+    tasks: [{
+      id: "update",
+      kind: "edit",
+      pick: true,
+      fields: ["body", "updatedAt"],
+      prefill: { updatedAt: "@today" },
+      label: studioLabel("Rechtstext aktualisieren", "Update a legal text", "Actualizar un texto legal", "Mettre \xE0 jour un texte juridique")
+    }],
+    fields: {
+      title: f.text(studioLabel("Titel", "Title", "T\xEDtulo", "Titre")),
+      description: f.longtext(studioLabel("Beschreibung", "Description", "Descripci\xF3n", "Description"), { optional: true }),
+      slug: f.slug(studioLabel("Adresse", "Address", "Direcci\xF3n", "Adresse"), { from: "title" }),
+      legalType: f.choice(studioLabel("Art", "Kind", "Tipo", "Type"), { options: legalTypes }),
+      updatedAt: f.date(studioLabel("Stand", "Last updated", "\xDAltima actualizaci\xF3n", "Derni\xE8re mise \xE0 jour")),
+      // Never machine-translated: a legal text in another language is a legal text of its own.
+      body: f.markdown(studioLabel("Text", "Text", "Texto", "Texte"), { translate: "manual" })
+    }
+  });
+}
+
+const slugField = () => f.slug(studioLabel("Adresse", "Address", "Direcci\xF3n", "Adresse"), { from: "name" });
+function people(o = {}) {
+  return collection({
+    label: o.label ?? studioLabel("Personen", "People", "Personas", "Personnes"),
+    ...sourceOf(o),
+    max: 100,
+    order: "manual",
+    ...o.route ? { route: o.route } : {},
+    tasks: [
+      { id: "add", kind: "create", label: studioLabel("Person hinzuf\xFCgen", "Add a person", "A\xF1adir una persona", "Ajouter une personne") },
+      { id: "edit", kind: "edit", pick: true, fields: ["name", "role", "bio", "email", "phone", "photo"], label: studioLabel("Person bearbeiten", "Edit a person", "Editar una persona", "Modifier une personne") },
+      { id: "remove", kind: "remove", label: studioLabel("Person entfernen", "Remove a person", "Eliminar una persona", "Retirer une personne") }
+    ],
+    fields: {
+      // A name is the same in every language.
+      name: f.text(studioLabel("Name", "Name", "Nombre", "Nom"), { translate: false }),
+      role: f.text(studioLabel("Rolle", "Role", "Funci\xF3n", "Fonction"), { optional: true }),
+      bio: f.longtext(studioLabel("Kurzbiografie", "Short bio", "Biograf\xEDa breve", "Courte biographie"), { optional: true }),
+      email: f.text(studioLabel("E-Mail", "Email", "Correo electr\xF3nico", "E-mail"), { optional: true, format: "email", translate: false }),
+      phone: f.text(studioLabel("Telefon", "Phone", "Tel\xE9fono", "T\xE9l\xE9phone"), { optional: true, format: "tel", translate: false }),
+      photo: f.image(studioLabel("Foto", "Photo", "Foto", "Photo"), { optional: true }),
+      // Only with a route: the stored shape of people without pages does not change.
+      // `o.route` is the runtime value of `R`, so the spread matches SlugOf<R>; TypeScript cannot narrow a generic by it.
+      ...o.route ? { slug: slugField() } : {}
+    }
+  });
+}
+function personJsonLd(p) {
+  return compact({
+    "@context": "https://schema.org",
+    "@type": "Person",
+    name: p.name,
+    jobTitle: p.role,
+    description: p.bio,
+    email: p.email,
+    telephone: p.phone,
+    image: p.image,
+    url: p.url,
+    worksFor: p.worksFor ? compact({ "@type": "Organization", name: p.worksFor.name, url: p.worksFor.url }) : void 0
+  });
+}
+
+function posts(o = {}) {
+  const tag = studioLabel("Schlagwort", "Tag", "Etiqueta", "Mot-cl\xE9");
+  return collection({
+    label: o.label ?? studioLabel("Beitr\xE4ge", "Posts", "Art\xEDculos", "Articles"),
+    ...sourceOf(o),
+    max: o.max ?? 500,
+    order: { field: "date", dir: "desc" },
+    ...o.route ? { route: o.route } : {},
+    fields: {
+      title: f.text(studioLabel("Titel", "Title", "T\xEDtulo", "Titre")),
+      description: f.longtext(studioLabel("Beschreibung", "Description", "Descripci\xF3n", "Description"), { optional: true }),
+      date: f.date(studioLabel("Datum", "Date", "Fecha", "Date")),
+      authors: f.refs(studioLabel("Autorinnen und Autoren", "Authors", "Autores", "Auteurs"), { to: o.authors ?? "authors", optional: true }),
+      image: f.image(studioLabel("Bild", "Image", "Imagen", "Image"), { optional: true }),
+      tags: f.list(studioLabel("Schlagw\xF6rter", "Tags", "Etiquetas", "Mots-cl\xE9s"), { itemLabel: tag, fields: { tag: f.text(tag, { max: 40 }) }, max: 10, optional: true }),
+      slug: f.slug(studioLabel("Adresse", "Address", "Direcci\xF3n", "Adresse"), { from: "title" }),
+      body: f.markdown(studioLabel("Text", "Text", "Texto", "Texte"), { profile: "page" })
+    }
+  });
+}
+function authors(o = {}) {
+  return collection({
+    label: o.label ?? studioLabel("Autorinnen und Autoren", "Authors", "Autores", "Auteurs"),
+    ...sourceOf(o),
+    max: 100,
+    order: "manual",
+    fields: {
+      name: f.text(studioLabel("Name", "Name", "Nombre", "Nom")),
+      role: f.text(studioLabel("Rolle", "Role", "Funci\xF3n", "Fonction"), { optional: true }),
+      avatar: f.image(studioLabel("Bild", "Image", "Imagen", "Image"), { optional: true }),
+      /** Shown as a link on the author's name. */
+      url: f.text(studioLabel("Website", "Website", "Sitio web", "Site web"), { format: "url", optional: true })
+    }
+  });
+}
+function changelog(o = {}) {
+  return collection({
+    label: o.label ?? studioLabel("\xC4nderungen", "Changelog", "Registro de cambios", "Journal des modifications"),
+    ...sourceOf(o),
+    max: o.max ?? 500,
+    order: { field: "date", dir: "desc" },
+    // A release written ahead is the normal case: an entry dated after the build day is scheduled, `draft: true` holds it back.
+    drafts: true,
+    fields: {
+      version: f.text(studioLabel("Version", "Version", "Versi\xF3n", "Version"), { max: 40, translate: false }),
+      date: f.date(studioLabel("Datum", "Date", "Fecha", "Date")),
+      body: f.markdown(studioLabel("Text", "Text", "Texto", "Texte"), { profile: "page" })
+    }
+  });
+}
+function releaseAnchor(version) {
+  return `v${version.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")}`;
+}
+function postJsonLd(p) {
+  return articleLd({
+    type: "BlogPosting",
+    title: p.title,
+    url: p.url,
+    description: p.description,
+    image: p.image,
+    published: p.date,
+    modified: p.modified,
+    author: p.authors,
+    keywords: p.tags,
+    lang: p.lang
+  });
+}
+
+const employmentTypes = [
+  { value: "fullTime", label: studioLabel("Vollzeit", "Full time", "Jornada completa", "Temps plein") },
+  { value: "partTime", label: studioLabel("Teilzeit", "Part time", "Media jornada", "Temps partiel") },
+  { value: "freelance", label: studioLabel("Freie Mitarbeit", "Freelance", "Aut\xF3nomo", "Ind\xE9pendant") },
+  { value: "internship", label: studioLabel("Praktikum", "Internship", "Pr\xE1cticas", "Stage") },
+  { value: "apprenticeship", label: studioLabel("Lehre", "Apprenticeship", "Formaci\xF3n profesional", "Apprentissage") }
+];
+const workPlaces = [
+  { value: "onsite", label: studioLabel("Vor Ort", "On site", "Presencial", "Sur place") },
+  { value: "hybrid", label: studioLabel("Hybrid", "Hybrid", "H\xEDbrido", "Hybride") },
+  { value: "remote", label: studioLabel("Remote", "Remote", "Remoto", "\xC0 distance") }
+];
+function jobs(o = {}) {
+  return collection({
+    label: o.label ?? studioLabel("Stellen", "Jobs", "Empleos", "Offres d\u2019emploi"),
+    ...sourceOf(o),
+    max: 30,
+    order: { field: "title", dir: "asc" },
+    ...o.route ? { route: o.route } : {},
+    visible: { mode: "until", field: "validUntil" },
+    tasks: [
+      { id: "add", kind: "create", label: studioLabel("Stelle ausschreiben", "Post a job", "Publicar una oferta", "Publier une offre") },
+      { id: "extend", kind: "edit", pick: true, fields: ["validUntil"], label: studioLabel("Bewerbungsfrist \xE4ndern", "Change the deadline", "Cambiar el plazo", "Modifier la date limite") },
+      { id: "remove", kind: "remove", label: studioLabel("Stelle entfernen", "Remove a job", "Eliminar una oferta", "Retirer une offre") }
+    ],
+    fields: {
+      title: f.text(studioLabel("Titel", "Title", "T\xEDtulo", "Titre")),
+      description: f.longtext(studioLabel("Kurzbeschreibung", "Short description", "Descripci\xF3n breve", "Description courte")),
+      slug: f.slug(studioLabel("Adresse", "Address", "Direcci\xF3n", "Adresse"), { from: "title" }),
+      location: f.text(studioLabel("Ort", "Location", "Ubicaci\xF3n", "Lieu")),
+      employmentType: f.choice(studioLabel("Anstellung", "Employment", "Tipo de contrato", "Type de contrat"), { options: employmentTypes }),
+      remote: f.choice(studioLabel("Arbeitsort", "Work place", "Lugar de trabajo", "Lieu de travail"), { options: workPlaces, default: "onsite" }),
+      applyUrl: f.text(studioLabel("Bewerbungs-Link", "Application link", "Enlace de solicitud", "Lien de candidature"), { format: "url", optional: true }),
+      applyEmail: f.text(studioLabel("Bewerbungs-E-Mail", "Application email", "Correo de solicitud", "E-mail de candidature"), { format: "email", optional: true }),
+      validUntil: f.date(studioLabel("Ausgeschrieben bis", "Open until", "Abierta hasta", "Ouverte jusqu\u2019au"), {
+        hint: studioLabel("Am Tag danach verschwindet die Stelle von der Website.", "The job leaves the website the day after.", "La oferta desaparece del sitio web al d\xEDa siguiente.", "L\u2019offre dispara\xEEt du site le lendemain.")
+      }),
+      body: f.markdown(studioLabel("Beschreibung", "Description", "Descripci\xF3n", "Description"))
+    }
+  });
+}
+const SCHEMA_EMPLOYMENT = {
+  fullTime: "FULL_TIME",
+  partTime: "PART_TIME",
+  freelance: "CONTRACTOR",
+  internship: "INTERN",
+  apprenticeship: "OTHER"
+};
+function jobJsonLd(j) {
+  const remote = j.remote === "remote";
+  return compact({
+    "@context": "https://schema.org",
+    "@type": "JobPosting",
+    title: j.title,
+    url: j.url,
+    description: j.description,
+    datePosted: j.datePosted,
+    validThrough: j.validUntil,
+    employmentType: j.employmentType && Object.hasOwn(SCHEMA_EMPLOYMENT, j.employmentType) ? SCHEMA_EMPLOYMENT[j.employmentType] : void 0,
+    hiringOrganization: compact({ "@type": "Organization", name: j.organization.name, sameAs: j.organization.url, logo: j.organization.logo }),
+    jobLocation: j.location ? { "@type": "Place", address: postalAddressLd({ city: j.location, country: j.country }) } : void 0,
+    jobLocationType: remote ? "TELECOMMUTE" : void 0,
+    applicantLocationRequirements: remote && j.country ? { "@type": "Country", name: j.country } : void 0
+  });
+}
+
+function faq(o = {}) {
+  return collection({
+    label: o.label ?? studioLabel("H\xE4ufige Fragen", "FAQ", "Preguntas frecuentes", "Questions fr\xE9quentes"),
+    ...sourceOf(o),
+    max: 100,
+    order: "manual",
+    tasks: [
+      { id: "add", kind: "create", label: studioLabel("Frage hinzuf\xFCgen", "Add a question", "A\xF1adir una pregunta", "Ajouter une question") },
+      { id: "edit", kind: "edit", pick: true, fields: ["question", "answer"], label: studioLabel("Frage bearbeiten", "Edit a question", "Editar una pregunta", "Modifier une question") },
+      { id: "remove", kind: "remove", label: studioLabel("Frage entfernen", "Remove a question", "Eliminar una pregunta", "Retirer une question") }
+    ],
+    fields: {
+      question: f.text(studioLabel("Frage", "Question", "Pregunta", "Question")),
+      answer: f.longtext(studioLabel("Antwort", "Answer", "Respuesta", "R\xE9ponse"))
+    }
+  });
+}
+function faqJsonLd(items) {
+  return faqLd([...items]);
+}
+
+function downloads(o = {}) {
+  return collection({
+    label: o.label ?? studioLabel("Downloads", "Downloads", "Descargas", "T\xE9l\xE9chargements"),
+    ...sourceOf(o),
+    max: 100,
+    order: { field: "date", dir: "desc" },
+    tasks: [
+      { id: "add", kind: "create", label: studioLabel("Datei hinzuf\xFCgen", "Add a file", "A\xF1adir un archivo", "Ajouter un fichier") },
+      { id: "edit", kind: "edit", pick: true, fields: ["title", "summary", "date", "file", "language"], label: studioLabel("Datei bearbeiten", "Edit a file", "Editar un archivo", "Modifier un fichier") },
+      { id: "remove", kind: "remove", label: studioLabel("Datei entfernen", "Remove a file", "Eliminar un archivo", "Retirer un fichier") }
+    ],
+    fields: {
+      title: f.text(studioLabel("Titel", "Title", "T\xEDtulo", "Titre")),
+      summary: f.longtext(studioLabel("Kurzbeschreibung", "Summary", "Resumen", "R\xE9sum\xE9"), { optional: true }),
+      date: f.date(studioLabel("Datum", "Date", "Fecha", "Date")),
+      file: f.file(studioLabel("Datei", "File", "Archivo", "Fichier"), { accept: ["pdf"], maxBytes: limitOf("file") }),
+      // The language of the document (a code such as `en`): one file serves every language of the site, so the list
+      // can say "in English" on the German page. Empty: the site's main language.
+      language: f.text(studioLabel("Sprache des Dokuments", "Language of the document", "Idioma del documento", "Langue du document"), {
+        optional: true,
+        translate: false,
+        max: 35,
+        hint: studioLabel("Sprachcode, zum Beispiel de oder en.", "A language code, for example en or de.", "Un c\xF3digo de idioma, por ejemplo es o en.", "Un code de langue, par exemple fr ou en.")
+      })
+    }
+  });
+}
+
+const escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+const rfc822 = (day) => (/* @__PURE__ */ new Date(`${day}T00:00:00Z`)).toUTCString();
+const tag = (name, value) => `<${name}>${escapeXml(value)}</${name}>`;
+function rssXml(feed) {
+  const items = feed.items.map((item) => [
+    "    <item>",
+    `      ${tag("title", item.title)}`,
+    `      ${tag("link", item.link)}`,
+    `      <guid isPermaLink="true">${escapeXml(item.link)}</guid>`,
+    `      ${tag("pubDate", rfc822(item.date))}`,
+    ...item.description ? [`      ${tag("description", item.description)}`] : [],
+    ...item.authors.map((a) => `      ${tag("dc:creator", a)}`),
+    "    </item>"
+  ].join("\n"));
+  const newest = feed.items.map((i) => i.date).sort().at(-1);
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">',
+    "  <channel>",
+    `    ${tag("title", feed.title)}`,
+    `    ${tag("link", feed.link)}`,
+    `    ${tag("description", feed.description)}`,
+    `    ${tag("language", feed.language)}`,
+    ...newest ? [`    ${tag("lastBuildDate", rfc822(newest))}`] : [],
+    `    <atom:link href="${escapeXml(feed.self)}" rel="self" type="application/rss+xml"/>`,
+    ...items,
+    "  </channel>",
+    "</rss>",
+    ""
+  ].join("\n");
+}
+
+const dayNames = { mo: "Monday", tu: "Tuesday", we: "Wednesday", th: "Thursday", fr: "Friday", sa: "Saturday", su: "Sunday" };
+const spanKey = (spans) => spans.map((s) => `${s.from}-${s.to}`).join(",");
+function weeklySpecs(week) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const key of weekdayKeys) {
+    const day = week.find((d) => d.day === key);
+    const spans = !day || day.closed ? [] : spansOf(day);
+    if (!spans.length) continue;
+    const k = spanKey(spans);
+    const group = groups.get(k) ?? { spans, days: [] };
+    group.days.push(key);
+    groups.set(k, group);
+  }
+  return [...groups.values()].flatMap((g) => g.spans.map((s) => ({ "@type": "OpeningHoursSpecification", dayOfWeek: g.days.map((d) => dayNames[d]), opens: s.from, closes: s.to })));
+}
+function specialSpecs(ctx, today, days, week) {
+  const runs = [];
+  for (let i = 0; i < days; i++) {
+    const date = addDays(today, i);
+    const rule = hoursOn(ctx, date);
+    const base = week.find((d) => d.day === weekdayOf(date));
+    const baseKey = !base || base.closed ? "" : spanKey(spansOf(base));
+    const key = rule.closed ? "" : spanKey(rule.times);
+    if (key === baseKey) continue;
+    const last = runs[runs.length - 1];
+    if (last && last.key === key && last.to === addDays(date, -1)) last.to = date;
+    else runs.push({ key, spans: rule.closed ? [] : rule.times, from: date, to: date });
+  }
+  return runs.flatMap((r) => (r.spans.length ? r.spans : [{ from: "00:00", to: "00:00" }]).map((s) => ({
+    "@type": "OpeningHoursSpecification",
+    validFrom: r.from,
+    validThrough: r.to,
+    opens: s.from,
+    closes: s.to
+  })));
+}
+function openingHoursJsonLd(ctx, today, days = 60) {
+  const { week } = weekFor(ctx, today);
+  const special = specialSpecs(ctx, today, days, week);
+  return { openingHoursSpecification: weeklySpecs(week), ...special.length ? { specialOpeningHoursSpecification: special } : {} };
+}
+
+function gallery(opts = {}) {
+  return single({
+    label: opts.label ?? both("Galerie", "Gallery"),
+    ...sourceOf(opts),
+    fields: {
+      images: f.list(both("Bilder", "Images"), { itemLabel: both("Bild", "Image"), fields: { image: f.image(both("Bild", "Image")) }, max: 24, default: [] })
+    },
+    tasks: [{ id: "edit", label: both("Fotos bearbeiten", "Edit photos"), kind: "edit", fields: ["images"] }]
+  });
+}
+
+export { authors, changelog, downloads, faq, faqJsonLd, gallery, hoursOn, jobJsonLd, jobs, legal, legalTypes, openingHoursJsonLd, people, personJsonLd, postJsonLd, posts, releaseAnchor, rssXml, site, siteJsonLd, spansOf, weekFor, weekdayOf };

package/dist/cli/index.mjs

@@ -2,12 +2,15 @@
 import { existsSync, realpathSync, readFileSync } from 'node:fs';
 import { join, dirname, resolve } from 'node:path';
 import { pathToFileURL, fileURLToPath } from 'node:url';
-import { f as fileLinkIssues } from '../shared/ginko.Dht0xxE5.mjs';
-import { n as coreMessage, i as isTranslatable } from '../shared/ginko.C-QjDn3O.mjs';
-import { s as serializeSchema, a as checkSite, G as validate, g as SITE_BUDGET, A as platformSchema, j as checkSchema } from '../shared/ginko.CrNRBkS5.mjs';
-import { e as defaultsFor, h as fieldsChanged, r as releaseData, m as markdownTrees, g as diffSchema } from '../shared/ginko.C90fPpMP.mjs';
+import { C as CliError, i as isObject, d as defaultsFor, f as fieldsChanged, r as releaseData, S as SITE_BUDGET, e as entryBytes, a as fitsBudget, b as diffSchema, l as largestEntryBytes, c as largestFieldBytes, p as parseExport, g as parseReleaseState, h as pathOf, j as defaultDir } from '../shared/ginko.t-gbwzxh.mjs';
+import { g as siteForContent } from '../shared/ginko.C-oz8wwI.mjs';
+import { f as fileLinkIssues } from '../shared/ginko.raCzOPYC.mjs';
+import { F as coreMessage, i as isTranslatable, g as effectiveMax } from '../shared/ginko.BNVC-g9n.mjs';
+import { s as serializeSchema, c as checkSite, v as validate, p as platformSchema, a as checkSchema } from '../shared/ginko.B1-DoOea.mjs';
+import { c as calendarOfCountry } from '../shared/ginko.D1PeQ3ds.mjs';
 import { mkdir, writeFile, rm, readdir } from 'node:fs/promises';
 import { execFile } from 'node:child_process';
+import '../shared/ginko.yKMIjJ68.mjs';
 import 'comark';
 import 'comark/plugins/alert';
 import 'comark/plugins/attributes';
@@ -20,30 +23,6 @@ import 'comark/plugins/mermaid';
 import 'comark/plugins/task-list';
 import 'comark/plugins/toc';
 import '@lupinum/ginko-i18n/core';
-import '../shared/ginko.CQvxhyez.mjs';
-
-class CliError extends Error {
-  code;
-  constructor(message, code = "INVALID") {
-    super(message);
-    this.code = code;
-  }
-}
-const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-function parseReleaseState(value) {
-  if (!isObject(value)) throw new CliError("The platform did not return a valid state.", "UNAVAILABLE");
-  const { site, schema, schemaRev, contentRev, migrations, entries } = value;
-  const valid = typeof site === "string" && isObject(schema) && isObject(schema.bricks) && Array.isArray(schema.migrations) && isObject(schema.retired) && typeof schemaRev === "number" && typeof contentRev === "number" && Array.isArray(migrations) && Array.isArray(entries) && entries.every((e) => isObject(e) && typeof e.id === "string" && typeof e.brick === "string" && isObject(e.data));
-  if (!valid) throw new CliError("The platform returned an incomplete state.", "UNAVAILABLE");
-  return value;
-}
-function parseExport(value, locator, problem) {
-  const optionalNumber = (v) => v === void 0 || typeof v === "number";
-  const optionalString = (v) => v === void 0 || typeof v === "string";
-  const valid = isObject(value) && value.format === 1 && typeof value.site === "string" && typeof value.name === "string" && typeof value.exportedAt === "string" && isObject(value.schema) && isObject(value.schema.bricks) && typeof value.schemaRev === "number" && typeof value.contentRev === "number" && Array.isArray(value.entries) && value.entries.every((e) => isObject(e) && typeof e.id === "string" && typeof e.brick === "string" && (e.kind === "single" || e.kind === "item") && typeof e.order === "number" && isObject(e.data) && isObject(e.prints) && typeof e.rev === "number" && optionalNumber(e.deletedAt)) && Array.isArray(value.files) && value.files.every((f) => isObject(f) && typeof f.id === "string" && typeof f.name === "string" && typeof f.mime === "string" && typeof f.size === "number" && typeof f[locator] === "string" && optionalNumber(f.width) && optionalNumber(f.height) && optionalString(f.folder) && optionalString(f.sha256) && (f.kept === void 0 || typeof f.kept === "boolean") && (f.focus === void 0 || isObject(f.focus) && typeof f.focus.x === "number" && typeof f.focus.y === "number")) && (value.folders === void 0 || Array.isArray(value.folders) && value.folders.every((f) => isObject(f) && typeof f.id === "string" && typeof f.name === "string" && optionalString(f.parent)));
-  if (!valid) throw new CliError(problem, "UNAVAILABLE" );
-  return value;
-}
 
 async function loadConfig(path, revision = 0) {
   const url = pathToFileURL(path).href + (revision > 0 ? `?rev=${revision}` : "");
@@ -57,13 +36,18 @@ async function loadConfig(path, revision = 0) {
   if (!isObject(config) || typeof config.site !== "string" || !isObject(config.bricks)) {
     throw new CliError(`${path} needs a default export with defineSite(\u2026).`);
   }
-  return config;
+  try {
+    return siteForContent(config, process.env.GINKO_CONTENT);
+  } catch (error) {
+    throw new CliError(error.message);
+  }
 }
 
 function english(m) {
   return coreMessage("en", m.key, m.params);
 }
 function explainRejected(rejected) {
+  if (rejected.length === 0) return [];
   const lines = ["The schema changes in a way that is not allowed:"];
   for (const r of rejected) {
     lines.push(`  \u2717 ${r.path}: ${english(r)}`);
@@ -109,8 +93,6 @@ async function checkFileLinks(input) {
   return ok;
 }
 
-const BUDGET = SITE_BUDGET;
-const byteSize = (value) => new TextEncoder().encode(JSON.stringify(value ?? null)).byteLength;
 async function buildCandidate(state, site, schema) {
   const problems = checkSite(site, schema);
   const applied = new Set([...state.schema.migrations, ...state.migrations].map((m) => m.id));
@@ -175,20 +157,27 @@ async function buildCandidate(state, site, schema) {
   }
   const changedData = new Map(changed.map((c) => [c.id, c.data]));
   const bytes = { site: 0, largest: 0 };
-  const count = (size, label) => {
+  let siteBefore = 0;
+  const limit = `the limit is ${kib(SITE_BUDGET.entryBytes)}`;
+  for (const entry of state.entries) {
+    if (entry.deletedAt !== null) continue;
+    const before = entryBytes(entry.data);
+    const next = changedData.get(entry.id);
+    const after = next ? entryBytes(next) : before;
+    siteBefore += before;
+    bytes.site += after;
+    bytes.largest = Math.max(bytes.largest, after);
+    if (!fitsBudget(after, before, SITE_BUDGET.entryBytes)) problems.push(`Entry ${entry.id} (${entry.brick}) would be ${kib(after)} after the release; ${limit}.`);
+  }
+  for (const single of created) {
+    const size = entryBytes(single.data);
     bytes.site += size;
     bytes.largest = Math.max(bytes.largest, size);
-    if (size > BUDGET.entryBytes) problems.push(`${label} is too large (at most 256 KiB).`);
-  };
-  const sizeOf = async (brick, data) => {
-    const fields = (schema.bricks[brick] ?? state.schema.bricks[brick])?.fields ?? {};
-    return byteSize(data) + byteSize(await markdownTrees(fields, data));
-  };
-  for (const entry of state.entries) count(await sizeOf(entry.brick, changedData.get(entry.id) ?? entry.data), `Entry ${entry.id} (${entry.brick})`);
-  for (const single of created) count(await sizeOf(single.brick, single.data), `The new single brick \u201C${single.brick}\u201D`);
-  if (bytes.site > BUDGET.siteBytes) problems.push("The site has reached its storage budget (4 MiB).");
+    if (size > SITE_BUDGET.entryBytes) problems.push(`The new single brick \u201C${single.brick}\u201D would be ${kib(size)}; ${limit}.`);
+  }
+  if (!fitsBudget(bytes.site, siteBefore, SITE_BUDGET.siteBytes)) problems.push(`The site would use ${kib(bytes.site)} of its ${kib(SITE_BUDGET.siteBytes)} of storage.`);
   const liveEntries = state.entries.filter((entry) => entry.deletedAt === null).length;
-  if (liveEntries + created.length > BUDGET.entries) problems.push(`The site has reached its limit of ${BUDGET.entries} entries.`);
+  if (liveEntries + created.length > SITE_BUDGET.entries) problems.push(`The site has reached its limit of ${SITE_BUDGET.entries} entries.`);
   return {
     schema,
     writes: [...writes].map(([entry, fields]) => ({ entry, fields })),
@@ -246,6 +235,8 @@ async function check(input) {
     for (const problem of problems) input.log(`  \u2717 ${problem}`);
     return false;
   }
+  warnEntrySize(input.config, input.log);
+  warnNoCalendar(input.config, input.log);
   const image = checkSeoImage(input.config, input.root, input.log);
   const links = await checkFileLinks({ config: input.config, root: input.root, log: input.log, fetch: input.fetch }) && image;
   if (!input.connect) {
@@ -260,6 +251,26 @@ async function check(input) {
     return false;
   }
 }
+function warnEntrySize(config, log) {
+  const { bricks, locales } = platformSchema(serializeSchema(config));
+  for (const [key, brick] of Object.entries(bricks)) {
+    const max = largestEntryBytes(brick.fields, locales);
+    if (max <= SITE_BUDGET.entryBytes) continue;
+    const fields = Object.entries(brick.fields).map(([name, field]) => ({ name, field, bytes: largestFieldBytes(field, locales) }));
+    const largest = fields.filter((f) => f.bytes > 0).sort((a, b) => b.bytes - a.bytes).slice(0, 3).map(({ name, field, bytes }) => {
+      if (field.type === "list") return `${name} ${field.max} rows`;
+      if (field.type !== "text" && field.type !== "longtext" && field.type !== "markdown") return `${name} ${kib(bytes)}`;
+      const languages = isTranslatable(field) && locales.length > 1 ? ` \xD7 ${locales.length} languages` : "";
+      return `${name} ${effectiveMax(field).toLocaleString("en-US")}${languages}`;
+    });
+    const uncounted = fields.filter(({ field }) => field.type === "ref" && field.multiple && field.max === void 0).map((f) => f.name);
+    log(`Warning: brick \u201C${key}\u201D can hold about ${kib(max)} per entry (largest: ${largest.join(", ")}); the entry limit is ${kib(SITE_BUDGET.entryBytes)}. Lower a max so a full entry fits.${uncounted.length ? ` Not counted: ${uncounted.join(", ")} (entries without a max).` : ""}`);
+  }
+}
+function warnNoCalendar(config, log) {
+  if (config.country === void 0 || config.calendar !== void 0 || calendarOfCountry(config.country)) return;
+  log(`Warning: Ginko has no public-holiday calendar for country \u201C${config.country}\u201D, so opening hours count no public holidays (stored as holidays: 'none'). Set \`calendar\` in ginko.config.ts to your own function (year) => holidays, or to 'none' to keep it so.`);
+}
 function checkSeoImage(config, root, log) {
   const image = config.seo?.image;
   if (!image || !image.startsWith("/") || image.startsWith("//")) return true;
@@ -286,7 +297,7 @@ async function checkRelease(input) {
   const candidate = result.candidate;
   const migrations = result.schema.migrations.filter((m) => !state.migrations.some((s) => s.id === m.id) && !state.schema.migrations.some((s) => s.id === m.id));
   if (migrations.length > 0) input.log(`New migrations: ${migrations.map((m) => m.id).join(", ")}. Writes: ${candidate.writes.length} entries.`);
-  input.log(`Size: site ${kib(candidate.bytes.site)} of 4 MiB, largest entry ${kib(candidate.bytes.largest)} (limit 256 KiB).`);
+  input.log(`Size: site ${kib(candidate.bytes.site)} of ${kib(SITE_BUDGET.siteBytes)}, largest entry ${kib(candidate.bytes.largest)} (limit ${kib(SITE_BUDGET.entryBytes)}).`);
   if (candidate.problems.length > 0) {
     for (const line of explainProblems(candidate.problems)) input.log(line);
     return false;
@@ -391,24 +402,11 @@ function createPlatform(options) {
   };
 }
 
-const EXTENSIONS = {
-  "image/jpeg": ".jpg",
-  "image/png": ".png",
-  "image/webp": ".webp",
-  "image/avif": ".avif",
-  "application/pdf": ".pdf"
-};
 function siteOfKey(key) {
   const match = PUSH_KEY_FORMAT.exec(key.trim());
   if (!match) throw new CliError("GINKO_KEY is not a valid key.", "USAGE");
   return match[1];
 }
-function defaultDir(site, now) {
-  return `ginko-export-${site}-${now.toISOString().slice(0, 10)}`;
-}
-function pathOf(file) {
-  return `files/${file.id}${EXTENSIONS[file.mime] ?? ""}`;
-}
 async function requireEmpty(dir) {
   let names;
   try {
@@ -543,6 +541,10 @@ function parseArgs(argv) {
       const value = arg === "--config" ? argv[++i] : arg.slice("--config=".length);
       if (!value) throw new CliError("--config needs a path.", "USAGE");
       args.config = value;
+    } else if (arg === "--site" || arg.startsWith("--site=")) {
+      const value = arg === "--site" ? argv[++i] : arg.slice("--site=".length);
+      if (!value) throw new CliError("--site needs a site slug.", "USAGE");
+      args.site = value;
     } else if (arg.startsWith("-")) args.flags.add(arg);
     else if (args.command === void 0) args.command = arg;
     else if (args.folder === void 0) args.folder = arg;
@@ -568,6 +570,7 @@ async function runCli(argv, deps, cli) {
     const name = `${cli.prefix}${args.command}`;
     const flag = [...args.flags].find((f) => f !== "--json" && !command.flags?.includes(f));
     if (flag) throw new CliError(`Unknown option \u201C${flag}\u201D for ${name}.`, "USAGE");
+    if (args.site !== void 0 && !command.site) throw new CliError(`Unknown option \u201C--site\u201D for ${name}.`, "USAGE");
     if (args.folder !== void 0 && !command.folder) throw new CliError(`Unexpected argument \u201C${args.folder}\u201D for ${name}.`, "USAGE");
     if (args.folder === void 0 && command.folder === "required") throw new CliError(`${name} needs a folder: ${name} <folder>.`, "USAGE");
     return command.run(args);

package/dist/index.d.mts

@@ -1,6 +1,7 @@
-export { L as LinkConfig, M as Migration, b as MigrationContext, R as Redirect, c as RouteTemplate, S as SiteInput, e as collection, f as defineSite, s as single } from './shared/ginko.akHewCGt.mjs';
-export { B as Brick, d as BrickSource, k as ChoiceOption, e as CollectionBrick, m as ComponentDef, a as ComponentRegistry, C as Currency, q as DataOf, t as Field, F as Fields, v as FileValue, y as ImageValue, z as ItemOf, J as Json, c as Label, L as Locale, Q as MarkdownProfile, U as MarkdownToc, M as MarkdownTree, X as MarkdownValue, Z as Money, f as SingleBrick, T as Task, a8 as TocLink, ab as UnknownChoice, V as Visibility, W as WeekInfo, aj as defineComponents, ao as f, au as plainText, ax as startOfWeek } from './shared/ginko.D-fNojn9.mjs';
-export { C as Condition, N as NavNode, Q as Query, d as SeoImage, j as formatMoney, s as safeHref } from './shared/ginko.BTUfZCfa.mjs';
-import './shared/ginko.Bwan3BB-.mjs';
+export { L as LinkConfig, M as Migration, b as MigrationContext, c as Redirect, R as RouteTemplate, S as SiteInput, e as collection, f as defineSite, s as single } from './shared/ginko.DkIc0ZZk.mjs';
+export { B as Brick, d as BrickSource, Q as BrickStatus, Y as ChoiceOption, f as CollectionBrick, e as CollectionStatus, _ as ComponentDef, b as ComponentRegistry, C as Currency, a2 as DataOf, p as Field, F as Fields, a4 as FileValue, a7 as ImageValue, a8 as ItemOf, J as Json, c as Label, L as Locale, ab as MarkdownProfile, ac as MarkdownToc, M as MarkdownTree, ad as MarkdownValue, af as Money, h as SingleBrick, g as SingleStatus, T as Task, al as TocLink, ao as UnknownChoice, V as Visibility, W as WeekInfo, aw as defineComponents, aB as f, aJ as plainText, aM as startOfWeek, aQ as wordsOf } from './shared/ginko.DrkUeYFP.mjs';
+export { N as NavNode, b as SeoImage, e as breadcrumbJsonLd } from './shared/ginko.o1yIKlgj.mjs';
+export { C as Condition, F as FormatMoneyOptions, Q as Query, f as formatMoney, s as safeHref } from './shared/ginko.BaFweQcB.mjs';
+import './shared/ginko.6cI8KXZP.mjs';
 import '@lupinum/ginko-i18n/core';
 import 'comark';