@seamlet/astro 0.8.1 → 0.10.0

package/README.md

@@ -10,7 +10,19 @@ Connects an [Astro](https://astro.build) site to the Seamlet CMS ([source](https
    npm install @seamlet/astro
    ```
 
-2. Describe the content with a schema, and mark the elements that show it:
+2. Name the site in `seamlet.json` at its root: its id in the CMS (lower-case letters, digits and single hyphens; its address there, `/sites/<id>`, the name of its content and the host of its preview), how the CMS names it, and the CMS it belongs to. The CMS reads the same file from the site's repository, so the id is written once.
+
+   ```json
+   {
+     "id": "zerno",
+     "title": "Кофейня «Зерно»",
+     "cms": "https://cms.seamlet.ru"
+   }
+   ```
+
+   The environment variable `CMS_ORIGIN` takes the place of `cms` when it is set: a build for a CMS in development, or the CMS's own builder. A build without the file, or with a field it cannot read, stops and says which field to fix.
+
+3. Describe the content with a schema, and mark the elements that show it:
 
    ```ts
    // src/schema.ts
@@ -46,35 +58,38 @@ Connects an [Astro](https://astro.build) site to the Seamlet CMS ([source](https
    <h1 {...edit("title")}>{content.title}</h1>
    ```
 
-3. Name the site's address in the CMS and its pages: components that take the content as their `content` prop.
+4. Describe the site for the CMS in `src/seamlet.ts`: its schema, the content it starts with, and its pages, each with the name the editor gives it and the component that renders it (it takes the content as its `content` prop). The home page `/` comes first; `searchTexts` names where the content holds a page's title and description for search engines, a group of a `title` and a `description` text (`seoFields`).
 
    ```ts
    // src/seamlet.ts
    import { defineSeamletSite } from "@seamlet/astro/site";
    import HomePage from "./components/HomePage.astro";
+   import { initialContent } from "./initial-content";
    import { schema } from "./schema";
 
    export default defineSeamletSite({
-     id: "zerno",
      schema,
-     pages: { "/": HomePage },
+     initialContent,
+     pages: {
+       "/": { title: "Главная", component: HomePage, searchTexts: "seo.home" },
+     },
    });
    ```
 
-4. Add the integration:
+   The CMS takes all of it from the site itself, so connecting a site, or changing its schema, needs no change of the CMS.
+
+5. Add the integration; it reads `seamlet.json` and `src/seamlet.ts` itself:
 
    ```js
    // astro.config.mjs
    import seamlet from "@seamlet/astro";
 
    export default defineConfig({
-     integrations: [
-       seamlet({ cms: "https://cms.example.com", site: "./src/seamlet.ts" }),
-     ],
+     integrations: [seamlet()],
    });
    ```
 
-The site's pages take their published content with `site.loadPublishedContent()`: at build time for a static site, on request otherwise.
+The site's pages take their published content with `site.loadPublishedContent()`: at build time for a static site, on request otherwise. A module that needs the content without importing every page takes it with `loadPublishedContent(schema)` of `@seamlet/astro/site`.
 
 ## Fields
 
@@ -135,9 +150,9 @@ const MENU_FILES = import.meta.glob<{ default: ImageMetadata }>(
 );
 
 export default defineSeamletSite({
-  id: "zerno",
   schema,
-  pages: { "/": HomePage },
+  initialContent,
+  pages: { "/": { title: "Главная", component: HomePage } },
   photos: (src) => MENU_FILES[src.replace("/menu/", "./assets/menu/")]?.default,
 });
 ```
@@ -219,9 +234,10 @@ What was opened stays open while the page is rendered anew after every edit.
 
 - `/preview` and `/preview/<page>`: the preview the CMS's editor frames. `GET` shows the published content; `POST` with the content as JSON shows that content without saving it, which is how the editor shows every edit at once. Only the CMS may frame it (`Content-Security-Policy: frame-ancestors`), and it is never indexed or cached.
 - The bridge on the preview: it tells the editor where the marked elements are and what a person does on the page, and types texts in place, formatted ones too.
+- `/seamlet/site.json`: what the site tells the CMS about itself (`SITE_DESCRIPTION_PATH`): its id and name from `seamlet.json`, its schema, the content it starts with and its pages. The CMS reads it with `readSiteDescription` whenever the site is opened in its editor.
 - `/seamlet-photos/<address>`: the site's own photo at an address its content gives it, found by `photos` of `defineSeamletSite`, for the CMS's editor.
 - `/media/<site>/<file>`: the photos uploaded in the CMS, taken from it on request; a static build copies every uploaded photo its built pages refer to next to them, so a static host serves them too.
 
 A site never renders content as raw HTML (`set:html`): the editor acts on what its preview says.
 
-The preview's address goes on the site's settings page in the CMS: `https://<site>/preview`.
+To connect the site, an administrator of the CMS gives it the preview's address, `https://<site>/preview`; the CMS takes the site's description from its origin.

package/dist/bridge.js

@@ -18,7 +18,7 @@ import {
   shortcutOf,
   toggleList,
   toggleMark
-} from "./chunk-27XIZEVS.js";
+} from "./chunk-2E7VDSUK.js";
 import {
   FIELD_PATH_ATTRIBUTE,
   REVEALED_ATTRIBUTE,
@@ -27,7 +27,7 @@ import {
   asOneParagraph,
   readRichText,
   resolveFieldPath
-} from "./chunk-ZUJEM3P7.js";
+} from "./chunk-DRDPKFHZ.js";
 
 // src/bridge/typed-fields.ts
 function typedKindAt(schema, path) {

package/dist/{chunk-27XIZEVS.js → chunk-2E7VDSUK.js}

@@ -3,7 +3,7 @@ import {
   normalizedLine,
   readRichText,
   resolveFieldPath
-} from "./chunk-ZUJEM3P7.js";
+} from "./chunk-DRDPKFHZ.js";
 
 // src/bridge/editor-shortcuts.ts
 function shortcutOf(event) {

package/dist/{chunk-ZUJEM3P7.js → chunk-DRDPKFHZ.js}

@@ -786,6 +786,223 @@ function openingHoursField(options = {}) {
   });
 }
 
+// src/schema/read-fields.ts
+function readFields(input) {
+  if (!isRecord2(input)) return void 0;
+  const entries = Object.entries(input).map(
+    ([name, value]) => [name, readField(value)]
+  );
+  const readEntries = entries.flatMap(
+    ([name, field]) => field === void 0 ? [] : [[name, field]]
+  );
+  const isEveryFieldRead = readEntries.length === entries.length;
+  return isEveryFieldRead ? Object.fromEntries(readEntries) : void 0;
+}
+function readField(input) {
+  if (!isRecord2(input)) return void 0;
+  const label = input["label"];
+  if (typeof label !== "string") return void 0;
+  const kind = input["kind"];
+  return isFieldKind(kind) ? readFieldOfKind(kind, label, input) : void 0;
+}
+function readFieldOfKind(kind, label, input) {
+  switch (kind) {
+    case "text":
+      return {
+        kind,
+        label,
+        ...optional("multiline", input["multiline"], isBoolean),
+        ...optional("maxLength", input["maxLength"], isCount)
+      };
+    case "richText":
+      return {
+        kind,
+        label,
+        ...optional("inline", input["inline"], isBoolean),
+        ...optional("maxLength", input["maxLength"], isCount)
+      };
+    case "number":
+      return {
+        kind,
+        label,
+        ...optional("min", input["min"], isNumber),
+        ...optional("max", input["max"], isNumber)
+      };
+    case "date":
+    case "image":
+    case "link":
+    case "toggle":
+    case "url":
+    case "time":
+      return { kind, label };
+    case "choice":
+    case "choices":
+      return readChoiceField(kind, label, input["options"]);
+    case "reference":
+    case "references":
+      return readReferenceField(kind, label, input["collection"]);
+    case "group":
+      return readGroupField(label, input["fields"]);
+    case "collection":
+      return readCollectionField(label, input);
+  }
+}
+function readChoiceField(kind, label, input) {
+  if (!Array.isArray(input)) return void 0;
+  const options = input;
+  if (!options.every(isChoiceOption)) return void 0;
+  const read = options.map(({ value, label: optionLabel }) => ({
+    value,
+    label: optionLabel
+  }));
+  return { kind, label, options: read };
+}
+function readReferenceField(kind, label, collection2) {
+  return typeof collection2 === "string" ? { kind, label, collection: collection2 } : void 0;
+}
+function readGroupField(label, input) {
+  const fields = readFields(input);
+  return fields === void 0 ? void 0 : { kind: "group", label, fields };
+}
+function readCollectionField(label, input) {
+  const item = readFields(input["item"]);
+  if (item === void 0 || "id" in item) return void 0;
+  const itemTitle = input["itemTitle"];
+  const isTitleKnown = typeof itemTitle === "string" && itemTitle in item;
+  if (itemTitle !== void 0 && !isTitleKnown) return void 0;
+  return {
+    kind: "collection",
+    label,
+    item,
+    ...isTitleKnown ? { itemTitle } : {}
+  };
+}
+function optional(key, value, isOfKind) {
+  if (!isOfKind(value)) return {};
+  return { [key]: value };
+}
+var FIELD_KINDS = /* @__PURE__ */ new Set([
+  "text",
+  "richText",
+  "number",
+  "date",
+  "image",
+  "link",
+  "toggle",
+  "choice",
+  "choices",
+  "url",
+  "time",
+  "reference",
+  "references",
+  "group",
+  "collection"
+]);
+function isFieldKind(value) {
+  return typeof value === "string" && FIELD_KINDS.has(value);
+}
+function isChoiceOption(value) {
+  return isRecord2(value) && typeof value["value"] === "string" && typeof value["label"] === "string";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isCount(value) {
+  return isNumber(value) && Number.isInteger(value) && value >= 0;
+}
+
+// src/schema/site-config.ts
+var SITE_CONFIG_FILE = "seamlet.json";
+var SITE_ID = /^[a-z0-9]+(-[a-z0-9]+)*$/u;
+var LONGEST_SITE_ID = 63;
+var WEB_PROTOCOLS = /* @__PURE__ */ new Set(["https:", "http:"]);
+var SITE_CONFIG_FIELDS = ["id", "title", "cms"];
+function isSiteId(value) {
+  return typeof value === "string" && value.length <= LONGEST_SITE_ID && SITE_ID.test(value);
+}
+function readSiteConfig(input) {
+  const fields = isRecord3(input) ? input : {};
+  const { id, title } = fields;
+  const cms = originOf(fields["cms"]);
+  const hasId = isSiteId(id);
+  const hasTitle = isText(title);
+  const hasCms = cms !== void 0;
+  if (hasId && hasTitle && hasCms) {
+    return { status: "read", config: { id, title: title.trim(), cms } };
+  }
+  const validity = {
+    id: hasId,
+    title: hasTitle,
+    cms: hasCms
+  };
+  const invalidFields = SITE_CONFIG_FIELDS.filter((field) => !validity[field]);
+  return { status: "invalid", invalidFields };
+}
+function originOf(value) {
+  if (typeof value !== "string" || !URL.canParse(value)) return void 0;
+  const url2 = new URL(value);
+  return WEB_PROTOCOLS.has(url2.protocol) ? url2.origin : void 0;
+}
+function isText(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/schema/site-description.ts
+var SITE_DESCRIPTION_PATH = "/seamlet/site.json";
+var PAGE_PATH = /^(\/[a-z0-9][a-z0-9-]*)+$/u;
+var HOME_PAGE_PATH = "/";
+function readSiteDescription(input) {
+  if (!isRecord4(input)) return void 0;
+  const { id, title } = input;
+  const schema = readFields(input["schema"]);
+  const isNamed = isSiteId(id) && isText2(title);
+  if (!isNamed || schema === void 0) return void 0;
+  const initial = parseContent(schema, input["initialContent"]);
+  const pages = readPages(schema, input["pages"]);
+  if (initial.issues.length > 0 || pages === void 0) return void 0;
+  return { id, title, schema, initialContent: initial.content, pages };
+}
+function isSearchTextsGroup(schema, path) {
+  const target = resolveFieldPath(schema, path);
+  if (target?.kind !== "field" || target.field.kind !== "group") return false;
+  const { title, description } = target.field.fields;
+  return title?.kind === "text" && description?.kind === "text";
+}
+function readPages(schema, input) {
+  if (!Array.isArray(input)) return void 0;
+  const entries = input;
+  const pages = entries.map((entry) => readPage(schema, entry));
+  const read = pages.flatMap((page) => page === void 0 ? [] : [page]);
+  const [first, ...rest] = read;
+  const paths = new Set(read.map((page) => page.path));
+  const isSound = read.length === pages.length && first?.path === HOME_PAGE_PATH && paths.size === read.length;
+  return isSound ? [first, ...rest] : void 0;
+}
+function readPage(schema, input) {
+  if (!isRecord4(input)) return void 0;
+  const { path, title, searchTexts } = input;
+  const isPath = typeof path === "string" && (path === HOME_PAGE_PATH || PAGE_PATH.test(path));
+  if (!isPath || !isText2(title)) return void 0;
+  if (searchTexts === void 0) return { path, title };
+  const isSearchTexts = typeof searchTexts === "string" && isSearchTextsGroup(schema, searchTexts);
+  return isSearchTexts ? { path, title, searchTexts } : void 0;
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isText2(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+
 export {
   defineSchema,
   text,
@@ -831,5 +1048,12 @@ export {
   seoFields,
   contactsFields,
   WEEKDAYS,
-  openingHoursField
+  openingHoursField,
+  readFields,
+  SITE_CONFIG_FILE,
+  isSiteId,
+  readSiteConfig,
+  SITE_DESCRIPTION_PATH,
+  readSiteDescription,
+  isSearchTextsGroup
 };

package/dist/index.d.ts

@@ -1,11 +1,5 @@
 import { AstroIntegration } from 'astro';
 
-interface SeamletOptions {
-    /** The address of the CMS, such as `https://cms.example.com`. */
-    readonly cms: string;
-    /** The module of the site, relative to the project: `defineSeamletSite(…)` as its default export. */
-    readonly site: string;
-}
-declare function seamlet(options: SeamletOptions): AstroIntegration;
+declare function seamlet(): AstroIntegration;
 
-export { type SeamletOptions, seamlet as default };
+export { seamlet as default };

package/dist/index.js

@@ -1,12 +1,18 @@
 import {
   OWN_PHOTOS_PATH
 } from "./chunk-3BS5CE26.js";
+import {
+  SITE_CONFIG_FILE,
+  SITE_DESCRIPTION_PATH,
+  readSiteConfig
+} from "./chunk-DRDPKFHZ.js";
 import {
   isUploadedPhoto
 } from "./chunk-P2OQOZBC.js";
 
 // src/index.ts
-import { fileURLToPath } from "url";
+import process from "process";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/uploaded-photos.ts
 import { mkdir, readdir, readFile, writeFile } from "fs/promises";
@@ -50,22 +56,78 @@ async function htmlFilesIn(directory) {
   return entries.filter((entry) => entry.isFile() && entry.name.endsWith(HTML_EXTENSION)).map((entry) => join(entry.parentPath, entry.name));
 }
 
+// src/site-config-file.ts
+import { readFile as readFile2 } from "fs/promises";
+import { fileURLToPath } from "url";
+var FIELD_RULES = {
+  id: "the site's id in the CMS: lower-case letters, digits and single hyphens, such as coffee-shop",
+  title: "how the CMS names the site, such as \xAB\u041A\u043E\u0444\u0435\u0439\u043D\u044F \xAB\u0417\u0435\u0440\u043D\u043E\xBB\xBB",
+  cms: "the address of the CMS, such as https://cms.seamlet.ru"
+};
+async function loadSiteConfig(root, cmsOverride) {
+  const file = new URL(SITE_CONFIG_FILE, root);
+  const parsed = await readJsonFile(file);
+  const input = cmsOverride === void 0 ? parsed : { ...asObject(parsed), cms: cmsOverride };
+  const reading = readSiteConfig(input);
+  if (reading.status === "read") return reading.config;
+  throw new Error(invalidFieldsMessage(file, reading.invalidFields));
+}
+async function readJsonFile(file) {
+  let text;
+  try {
+    text = await readFile2(file, "utf8");
+  } catch (error) {
+    throw new Error(
+      `@seamlet/astro: ${fileURLToPath(file)} is missing: the site names its id, its title and its CMS there`,
+      { cause: error }
+    );
+  }
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`@seamlet/astro: ${fileURLToPath(file)} is not JSON`, {
+      cause: error
+    });
+  }
+}
+function asObject(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function invalidFieldsMessage(file, fields) {
+  const lines = fields.map((field) => `  "${field}": ${FIELD_RULES[field]}`);
+  return [
+    `@seamlet/astro: ${fileURLToPath(file)} needs these fields:`,
+    ...lines
+  ].join("\n");
+}
+
 // src/index.ts
 var CONFIG_MODULE = "virtual:seamlet/config";
 var SITE_MODULE = "virtual:seamlet/site";
 var RESOLVED_CONFIG_MODULE = `\0${CONFIG_MODULE}`;
-function seamlet(options) {
-  const cmsOrigin = new URL(options.cms).origin;
+var SITE_MODULE_FILE = "src/seamlet.ts";
+var CMS_ORIGIN_VARIABLE = "CMS_ORIGIN";
+function seamlet() {
+  let siteConfig;
   return {
     name: "@seamlet/astro",
     hooks: {
-      "astro:config:setup": ({
+      "astro:config:setup": async ({
         config,
+        addWatchFile,
         injectRoute,
         injectScript,
         updateConfig
       }) => {
-        const siteModule = fileURLToPath(new URL(options.site, config.root));
+        const loaded = await loadSiteConfig(
+          config.root,
+          process.env[CMS_ORIGIN_VARIABLE]
+        );
+        siteConfig = loaded;
+        addWatchFile(new URL(SITE_CONFIG_FILE, config.root));
+        const siteModule = fileURLToPath2(
+          new URL(SITE_MODULE_FILE, config.root)
+        );
         updateConfig({
           vite: {
             plugins: [
@@ -76,7 +138,7 @@ function seamlet(options) {
                   if (id === SITE_MODULE) return siteModule;
                   return void 0;
                 },
-                load: (id) => id === RESOLVED_CONFIG_MODULE ? `export const cmsOrigin = ${JSON.stringify(cmsOrigin)};` : void 0
+                load: (id) => id === RESOLVED_CONFIG_MODULE ? configModuleOf(loaded) : void 0
               }
             ]
           }
@@ -92,6 +154,11 @@ function seamlet(options) {
           entrypoint: "@seamlet/astro/routes/media",
           prerender: false
         });
+        injectRoute({
+          pattern: SITE_DESCRIPTION_PATH,
+          entrypoint: "@seamlet/astro/routes/site-description",
+          prerender: false
+        });
         injectRoute({
           pattern: `${OWN_PHOTOS_PATH}/[...path]`,
           entrypoint: "@seamlet/astro/routes/own-photos",
@@ -102,15 +169,23 @@ function seamlet(options) {
       // the built pages refer to are copied next to them. Pages rendered on request take them
       // through the route above.
       "astro:build:done": async ({ dir, logger }) => {
+        if (siteConfig === void 0) return;
         const copied = await copyUploadedPhotos({
-          directory: fileURLToPath(dir),
-          cmsOrigin
+          directory: fileURLToPath2(dir),
+          cmsOrigin: siteConfig.cms
         });
         if (copied > 0) logger.info(`copied ${String(copied)} uploaded photos`);
       }
     }
   };
 }
+function configModuleOf(config) {
+  return [
+    `export const siteId = ${JSON.stringify(config.id)};`,
+    `export const siteTitle = ${JSON.stringify(config.title)};`,
+    `export const cmsOrigin = ${JSON.stringify(config.cms)};`
+  ].join("\n");
+}
 export {
   seamlet as default
 };

package/dist/protocol.js

@@ -22,8 +22,8 @@ import {
   shortcutOf,
   toggleList,
   toggleMark
-} from "./chunk-27XIZEVS.js";
-import "./chunk-ZUJEM3P7.js";
+} from "./chunk-2E7VDSUK.js";
+import "./chunk-DRDPKFHZ.js";
 export {
   OWN_PHOTOS_PATH,
   PROTOCOL_VERSION,

package/dist/routes/site-description.d.ts

@@ -0,0 +1,5 @@
+import { APIRoute } from 'astro';
+
+declare const GET: APIRoute;
+
+export { GET };

package/dist/routes/site-description.js

@@ -0,0 +1,8 @@
+// src/routes/site-description.ts
+import site from "virtual:seamlet/site";
+var GET = () => Response.json(site.description, {
+  headers: { "Cache-Control": "no-store", "X-Robots-Tag": "noindex" }
+});
+export {
+  GET
+};

package/dist/schema.d.ts

@@ -2,6 +2,7 @@ import { b as ImageValue, L as LinkValue, c as Field, d as CollectionField, F as
 export { i as ChoiceField, j as ChoiceOption, D as DateField, k as FieldKind, l as FieldValue, m as ImageFocus, N as NumberField, O as OptionValue, n as RecordOf, o as ReferenceField, p as ReferencesField, q as RichBlock, r as RichLine, s as RichSpan, R as RichText, t as RichTextField, u as ToggleField, V as ValueOf, v as asOneParagraph, w as choice, x as choices, y as collection, z as date, A as defaultContent, B as defaultValue, E as defineSchema, H as group, J as image, K as link, M as normalizedLine, P as number, Q as plainTextOf, S as readRichText, W as reference, X as references, Y as richText, Z as richTextOf, _ as text, $ as time, a0 as toggle, a1 as url } from './content-6k-E7NWf.js';
 import { F as FieldPath } from './parse-content-C9ldnmvj.js';
 export { C as ContentIssue, P as ParsedContent, c as countCharacters, f as formatFieldPath, p as parseContent } from './parse-content-C9ldnmvj.js';
+export { a as SITE_DESCRIPTION_PATH, S as SiteDescription, b as SitePageDescription, i as isSearchTextsGroup, r as readSiteDescription } from './site-description-4Jx6Nq6X.js';
 
 declare const FIELD_PATH_ATTRIBUTE = "data-cms-path";
 interface FieldMarker {
@@ -171,4 +172,30 @@ declare function openingHoursField(options?: {
     note: TextField;
 }>;
 
-export { ChoicesField, CollectionField, type CollectionRecords, Content, ContentOf, type ContentPath, FIELD_PATH_ATTRIBUTE, Field, type FieldMarker, FieldPath, type FieldTarget, Fields, GroupField, ImageField, ImageValue, LinkField, type LinkKind, type LinkTarget, LinkValue, RECORD_ID_KEY, REVEALED_ATTRIBUTE, REVEAL_ATTRIBUTE, REVEAL_EVENT, RecordFields, TextField, TimeField, UrlField, WEEKDAYS, collectionAt, contactsFields, editable, findRecord, hrefOf, imagePosition, isRecordId, linkTargetOf, newRecord, openingHoursField, resolveFieldPath, seoFields, withRecordIds };
+/** The schema the input describes, or undefined when it is not one. */
+declare function readFields(input: unknown): Fields | undefined;
+
+/** The file at the root of a site's repository. */
+declare const SITE_CONFIG_FILE = "seamlet.json";
+interface SiteConfig {
+    /** The site's id in the CMS: its address there (`/sites/<id>`) and the name of its content. */
+    readonly id: string;
+    /** How the CMS names the site: «Кофейня «Зерно»». */
+    readonly title: string;
+    /** The origin of the CMS the site belongs to: `https://cms.seamlet.ru`. */
+    readonly cms: string;
+}
+type SiteConfigField = keyof SiteConfig;
+type SiteConfigReading = {
+    readonly status: "read";
+    readonly config: SiteConfig;
+} | {
+    readonly status: "invalid";
+    /** The fields that are missing or not what they must be. */
+    readonly invalidFields: readonly SiteConfigField[];
+};
+declare function isSiteId(value: unknown): value is string;
+/** The config the input gives (the parsed `seamlet.json`); fields it does not know are left out. */
+declare function readSiteConfig(input: unknown): SiteConfigReading;
+
+export { ChoicesField, CollectionField, type CollectionRecords, Content, ContentOf, type ContentPath, FIELD_PATH_ATTRIBUTE, Field, type FieldMarker, FieldPath, type FieldTarget, Fields, GroupField, ImageField, ImageValue, LinkField, type LinkKind, type LinkTarget, LinkValue, RECORD_ID_KEY, REVEALED_ATTRIBUTE, REVEAL_ATTRIBUTE, REVEAL_EVENT, RecordFields, SITE_CONFIG_FILE, type SiteConfig, type SiteConfigField, type SiteConfigReading, TextField, TimeField, UrlField, WEEKDAYS, collectionAt, contactsFields, editable, findRecord, hrefOf, imagePosition, isRecordId, isSiteId, linkTargetOf, newRecord, openingHoursField, readFields, readSiteConfig, resolveFieldPath, seoFields, withRecordIds };

package/dist/schema.js

@@ -4,6 +4,8 @@ import {
   REVEALED_ATTRIBUTE,
   REVEAL_ATTRIBUTE,
   REVEAL_EVENT,
+  SITE_CONFIG_FILE,
+  SITE_DESCRIPTION_PATH,
   WEEKDAYS,
   asOneParagraph,
   choice,
@@ -24,6 +26,8 @@ import {
   image,
   imagePosition,
   isRecordId,
+  isSearchTextsGroup,
+  isSiteId,
   link,
   linkTargetOf,
   newRecord,
@@ -32,7 +36,10 @@ import {
   openingHoursField,
   parseContent,
   plainTextOf,
+  readFields,
   readRichText,
+  readSiteConfig,
+  readSiteDescription,
   reference,
   references,
   resolveFieldPath,
@@ -44,13 +51,15 @@ import {
   toggle,
   url,
   withRecordIds
-} from "./chunk-ZUJEM3P7.js";
+} from "./chunk-DRDPKFHZ.js";
 export {
   FIELD_PATH_ATTRIBUTE,
   RECORD_ID_KEY,
   REVEALED_ATTRIBUTE,
   REVEAL_ATTRIBUTE,
   REVEAL_EVENT,
+  SITE_CONFIG_FILE,
+  SITE_DESCRIPTION_PATH,
   WEEKDAYS,
   asOneParagraph,
   choice,
@@ -71,6 +80,8 @@ export {
   image,
   imagePosition,
   isRecordId,
+  isSearchTextsGroup,
+  isSiteId,
   link,
   linkTargetOf,
   newRecord,
@@ -79,7 +90,10 @@ export {
   openingHoursField,
   parseContent,
   plainTextOf,
+  readFields,
   readRichText,
+  readSiteConfig,
+  readSiteDescription,
   reference,
   references,
   resolveFieldPath,

package/dist/site-description-4Jx6Nq6X.d.ts

@@ -0,0 +1,36 @@
+import { F as Fields, a as Content } from './content-6k-E7NWf.js';
+
+/** Where a site hands out its description, on the origin of its preview. */
+declare const SITE_DESCRIPTION_PATH = "/seamlet/site.json";
+/** A page of a site, which the site renders itself. */
+interface SitePageDescription {
+    /** The address of the page on the site: `/` for the first page, `/menu` for others. */
+    readonly path: string;
+    /** How the editor names the page in its list of pages. */
+    readonly title: string;
+    /**
+     * Where the content holds what search engines and link previews show for the page
+     * (`seo.menu`): a group of a `title` and a `description` text.
+     */
+    readonly searchTexts?: string;
+}
+interface SiteDescription {
+    /** The address of the site in the CMS (`/sites/<id>`). */
+    readonly id: string;
+    /** How the CMS names the site. */
+    readonly title: string;
+    readonly schema: Fields;
+    /** The content shown and edited until the first save. */
+    readonly initialContent: Content;
+    /** The pages of the site; the first is the home page at `/`. */
+    readonly pages: readonly [SitePageDescription, ...SitePageDescription[]];
+}
+/**
+ * The description the input gives, or undefined when it is not a whole and sound one: a known
+ * schema, an initial content with nothing to fix, the home page first, each page once.
+ */
+declare function readSiteDescription(input: unknown): SiteDescription | undefined;
+/** Whether the path names a group of a `title` and a `description` text. */
+declare function isSearchTextsGroup(schema: Fields, path: string): boolean;
+
+export { type SiteDescription as S, SITE_DESCRIPTION_PATH as a, type SitePageDescription as b, isSearchTextsGroup as i, readSiteDescription as r };

package/dist/site.d.ts

@@ -1,16 +1,23 @@
 import { ImageMetadata } from 'astro';
 import { AstroComponentFactory } from 'astro/runtime/server/index.js';
 import { F as Fields, C as ContentOf } from './content-6k-E7NWf.js';
+import { S as SiteDescription } from './site-description-4Jx6Nq6X.js';
 
+/** A page of the site: how the editor names it, and the component that renders it. */
+interface SeamletPage {
+    readonly title: string;
+    /** A component that takes the site's content as its `content` prop. */
+    readonly component: AstroComponentFactory;
+    /** Where the content holds the page's title and description for search engines (`seo.menu`). */
+    readonly searchTexts?: string;
+}
+/** The site's content and pages; its id and title come from `seamlet.json`. */
 interface SeamletSiteDefinition<F extends Fields> {
-    /** The site's address in the CMS: `/sites/<id>`. */
-    readonly id: string;
     readonly schema: F;
-    /**
-     * The pages of the site by their address (`/`, `/menu`): components that take the site's content
-     * as their `content` prop. The CMS lists the same addresses for its editor.
-     */
-    readonly pages: Readonly<Record<string, AstroComponentFactory>>;
+    /** The content the site shows, and the CMS edits, until the first publication. */
+    readonly initialContent: ContentOf<F>;
+    /** The pages of the site by their address (`/`, `/menu`); the home page `/` comes first. */
+    readonly pages: Readonly<Record<string, SeamletPage>>;
     /**
      * The site's own photo at the address its content gives it (`/menu/cafe/01.jpg`), so the CMS's
      * editor can show it in the photo's field. A site without own photos leaves it out.
@@ -26,8 +33,15 @@ interface SeamletSite<F extends Fields = Fields> {
     readonly loadPublishedContent: () => Promise<ContentOf<F>>;
     /** The site's own photo at an address its content gives it, if it has one there. */
     readonly ownPhotoAt: (src: string) => ImageMetadata | undefined;
+    /** What the site tells the CMS about itself (`SITE_DESCRIPTION_PATH`). */
+    readonly description: SiteDescription;
 }
 /** Describes the site for the integration: `src/seamlet.ts` exports it as its default. */
 declare function defineSeamletSite<F extends Fields>(definition: SeamletSiteDefinition<F>): SeamletSite<F>;
+/**
+ * What the CMS published for the site, in the shape of its schema: the site's initial content until
+ * the first publication. For a module that needs the content without the pages.
+ */
+declare function loadPublishedContent<F extends Fields>(schema: F): Promise<ContentOf<F>>;
 
-export { type SeamletSite, type SeamletSiteDefinition, defineSeamletSite };
+export { type SeamletPage, type SeamletSite, type SeamletSiteDefinition, defineSeamletSite, loadPublishedContent };

package/dist/site.js

@@ -1,25 +1,51 @@
 import {
   parseContent
-} from "./chunk-ZUJEM3P7.js";
+} from "./chunk-DRDPKFHZ.js";
+
+// src/site.ts
+import { cmsOrigin, siteId, siteTitle } from "virtual:seamlet/config";
+
+// src/site-descriptions.ts
+function describeSite(identity, definition) {
+  const pages = Object.entries(definition.pages).map(
+    ([path, page]) => ({
+      path,
+      title: page.title,
+      ...page.searchTexts === void 0 ? {} : { searchTexts: page.searchTexts }
+    })
+  );
+  const [home, ...rest] = pages;
+  if (home === void 0) {
+    throw new Error(`The site "${identity.id}" has no pages`);
+  }
+  return {
+    id: identity.id,
+    title: identity.title,
+    schema: definition.schema,
+    initialContent: definition.initialContent,
+    pages: [home, ...rest]
+  };
+}
 
 // src/site.ts
-import { cmsOrigin } from "virtual:seamlet/config";
 var HOME_PAGE_PATH = "/";
 function defineSeamletSite(definition) {
   const pages = new Map(Object.entries(definition.pages));
   return {
-    id: definition.id,
+    id: siteId,
     schema: definition.schema,
-    pageAt: (rest) => pages.get(rest === void 0 ? HOME_PAGE_PATH : `/${rest}`),
-    loadPublishedContent: async () => {
-      const published = await fetchPublished(definition.id);
-      return parseContent(definition.schema, published).content;
-    },
-    ownPhotoAt: (src) => definition.photos?.(src)
+    pageAt: (rest) => pages.get(rest === void 0 ? HOME_PAGE_PATH : `/${rest}`)?.component,
+    loadPublishedContent: () => loadPublishedContent(definition.schema),
+    ownPhotoAt: (src) => definition.photos?.(src),
+    description: describeSite({ id: siteId, title: siteTitle }, definition)
   };
 }
-async function fetchPublished(siteId) {
-  const url = new URL(`/api/sites/${siteId}/published`, cmsOrigin);
+async function loadPublishedContent(schema) {
+  const published = await fetchPublished(siteId);
+  return parseContent(schema, published).content;
+}
+async function fetchPublished(id) {
+  const url = new URL(`/api/sites/${id}/published`, cmsOrigin);
   const response = await fetch(url);
   if (!response.ok) {
     throw new Error(
@@ -29,5 +55,6 @@ async function fetchPublished(siteId) {
   return response.json();
 }
 export {
-  defineSeamletSite
+  defineSeamletSite,
+  loadPublishedContent
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seamlet/astro",
-  "version": "0.8.1",
+  "version": "0.10.0",
   "description": "Connects an Astro site to the Seamlet CMS: the schema of its content, the preview the editor frames, and its published content.",
   "license": "MIT",
   "type": "module",
@@ -47,6 +47,10 @@
       "types": "./dist/routes/own-photos.d.ts",
       "default": "./dist/routes/own-photos.js"
     },
+    "./routes/site-description": {
+      "types": "./dist/routes/site-description.d.ts",
+      "default": "./dist/routes/site-description.js"
+    },
     "./components/RichText.astro": "./components/RichText.astro"
   },
   "files": [