@seamlet/astro 0.9.0 → 0.11.0

package/README.md

@@ -4,13 +4,34 @@ Connects an [Astro](https://astro.build) site to the Seamlet CMS ([source](https
 
 ## How a site connects
 
+The quick way, in an Astro project:
+
+```bash
+npx @seamlet/astro init --title "Кофейня «Зерно»"   # seamlet.json, src/schema.ts, src/seamlet.ts, a first page component
+npx astro add @seamlet/astro node                   # the integration, and an adapter for the preview
+```
+
+`init` takes the id from the name in `package.json` unless `--id` gives it, and the CMS `https://cms.seamlet.ru` unless `--cms` names another; it never overwrites a file the site has, and says what to render in a page. The steps below are what it starts, one by one.
+
 1. Install the package. The site needs an adapter, because the preview is rendered on request; its own pages may stay static.
 
    ```bash
    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,7 +67,7 @@ Connects an [Astro](https://astro.build) site to the Seamlet CMS ([source](https
    <h1 {...edit("title")}>{content.title}</h1>
    ```
 
-3. Describe the site for the CMS: its address and name there, 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`).
+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
@@ -56,8 +77,6 @@ Connects an [Astro](https://astro.build) site to the Seamlet CMS ([source](https
    import { schema } from "./schema";
 
    export default defineSeamletSite({
-     id: "zerno",
-     title: "Кофейня «Зерно»",
      schema,
      initialContent,
      pages: {
@@ -68,20 +87,18 @@ Connects an [Astro](https://astro.build) site to the Seamlet CMS ([source](https
 
    The CMS takes all of it from the site itself, so connecting a site, or changing its schema, needs no change of the CMS.
 
-4. Add the integration:
+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. A module that needs the content without importing every page takes it with `loadPublishedContent(id, schema)` of `@seamlet/astro/site`.
+The site's pages take their published content with `site.loadPublishedContent()`: at build time for a static site, on request otherwise. Until the first publication, and while the CMS does not know the site yet (a site connected from its repository is built before that), it is the site's initial content; any other refusal of the CMS stops the build. A module that needs the content without importing every page takes it with `loadPublishedContent(schema)` of `@seamlet/astro/site`.
 
 ## Fields
 
@@ -142,8 +159,6 @@ const MENU_FILES = import.meta.glob<{ default: ImageMetadata }>(
 );
 
 export default defineSeamletSite({
-  id: "zerno",
-  title: "Кофейня «Зерно»",
   schema,
   initialContent,
   pages: { "/": { title: "Главная", component: HomePage } },
@@ -228,7 +243,7 @@ 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 name, 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/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.
 

package/dist/bridge.js

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

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

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

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

@@ -917,16 +917,54 @@ 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 SITE_ID = /^[a-z0-9]+(-[a-z0-9]+)*$/u;
 var PAGE_PATH = /^(\/[a-z0-9][a-z0-9-]*)+$/u;
 var HOME_PAGE_PATH = "/";
 function readSiteDescription(input) {
-  if (!isRecord3(input)) return void 0;
+  if (!isRecord4(input)) return void 0;
   const { id, title } = input;
   const schema = readFields(input["schema"]);
-  const isNamed = typeof id === "string" && SITE_ID.test(id) && isText(title);
+  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"]);
@@ -950,18 +988,18 @@ function readPages(schema, input) {
   return isSound ? [first, ...rest] : void 0;
 }
 function readPage(schema, input) {
-  if (!isRecord3(input)) return void 0;
+  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 || !isText(title)) return void 0;
+  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 isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isText(value) {
+function isText2(value) {
   return typeof value === "string" && value.trim() !== "";
 }
 
@@ -1012,6 +1050,9 @@ export {
   WEEKDAYS,
   openingHoursField,
   readFields,
+  SITE_CONFIG_FILE,
+  isSiteId,
+  readSiteConfig,
   SITE_DESCRIPTION_PATH,
   readSiteDescription,
   isSearchTextsGroup

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+import {
+  SITE_CONFIG_FILE,
+  isSiteId,
+  readSiteConfig
+} from "./chunk-DRDPKFHZ.js";
+
+// src/cli.ts
+import process from "process";
+
+// src/init/init-command.ts
+import { readFile } from "fs/promises";
+import { join as join2 } from "path";
+import { parseArgs } from "util";
+
+// src/init/site-files.ts
+var SITE_MODULE_PATH = "src/seamlet.ts";
+var SCHEMA_PATH = "src/schema.ts";
+var HOME_PAGE_PATH = "src/components/HomePage.astro";
+var JSON_INDENT = 2;
+function siteFilesOf(config) {
+  return [
+    {
+      path: SITE_CONFIG_FILE,
+      text: `${JSON.stringify(config, null, JSON_INDENT)}
+`
+    },
+    { path: SCHEMA_PATH, text: schemaModuleOf(config.title) },
+    { path: SITE_MODULE_PATH, text: SITE_MODULE },
+    { path: HOME_PAGE_PATH, text: HOME_PAGE }
+  ];
+}
+function siteIdOf(packageName) {
+  const unscoped = packageName.replace(/^@[^/]+\//u, "");
+  const id = unscoped.toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "");
+  return isSiteId(id) ? id : void 0;
+}
+function schemaModuleOf(title) {
+  return `import { defineSchema, text, type ContentOf } from "@seamlet/astro/schema";
+
+// What the site's owner edits in the CMS. Add a field here, show it on a page and mark its element
+// with edit(...): the CMS builds its form from this schema alone.
+export const schema = defineSchema({
+  title: text({ label: "\u0417\u0430\u0433\u043E\u043B\u043E\u0432\u043E\u043A", maxLength: 80 }),
+});
+
+export type Content = ContentOf<typeof schema>;
+
+/** What the site shows, and the CMS edits, until the first publication. */
+export const initialContent: Content = {
+  title: ${JSON.stringify(title)},
+};
+`;
+}
+var SITE_MODULE = `import { defineSeamletSite } from "@seamlet/astro/site";
+import HomePage from "./components/HomePage.astro";
+import { initialContent, schema } from "./schema";
+
+// The site as the CMS knows it: its schema, the content it starts with and its pages (its id and
+// title are in seamlet.json). Every page is a component that takes the content as its prop.
+export default defineSeamletSite({
+  schema,
+  initialContent,
+  pages: {
+    "/": { title: "\u0413\u043B\u0430\u0432\u043D\u0430\u044F", component: HomePage },
+  },
+});
+`;
+var HOME_PAGE = `---
+import { editable } from "@seamlet/astro/schema";
+import type { Content } from "../schema";
+
+interface Props {
+  content: Content;
+}
+
+const { content } = Astro.props;
+// The CMS's editor lets the owner click the marked elements; a path the content lacks does not compile.
+const edit = editable<Content>();
+---
+
+<h1 {...edit("title")}>{content.title}</h1>
+`;
+
+// src/init/write-site-files.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+var ALREADY_EXISTS = "EEXIST";
+async function writeSiteFiles(root, files) {
+  const written = [];
+  const kept = [];
+  for (const file of files) {
+    const isWritten = await writeNewFile(join(root, file.path), file.text);
+    (isWritten ? written : kept).push(file.path);
+  }
+  return { written, kept };
+}
+async function writeNewFile(path, text) {
+  await mkdir(dirname(path), { recursive: true });
+  try {
+    await writeFile(path, text, { flag: "wx" });
+    return true;
+  } catch (error) {
+    if (isAlreadyThere(error)) return false;
+    throw new Error(`@seamlet/astro: cannot write ${path}`, { cause: error });
+  }
+}
+function isAlreadyThere(error) {
+  return error instanceof Error && "code" in error && error.code === ALREADY_EXISTS;
+}
+
+// src/init/init-command.ts
+var DEFAULT_CMS = "https://cms.seamlet.ru";
+var SUCCESS = 0;
+var FAILURE = 1;
+var MISUSE = 2;
+var USAGE = `Usage: npx @seamlet/astro init [--id <id>] [--title <title>] [--cms <address>]
+
+Writes ${SITE_CONFIG_FILE} and a first module of the site in the Astro project here. The id is the
+site's name in the CMS (lower-case letters, digits and hyphens); by default it comes from the
+name in package.json, the title from the id, the CMS is ${DEFAULT_CMS}.`;
+var NEXT_STEPS = `
+Next:
+  npx astro add @seamlet/astro node    the integration, and an adapter for the preview
+  render a page with its content, such as src/pages/index.astro:
+    ---
+    import site from "../seamlet";
+    import HomePage from "../components/HomePage.astro";
+    const content = await site.loadPublishedContent();
+    ---
+    <HomePage content={content} />`;
+async function runInit(run) {
+  const options = optionsOf(run.argv);
+  if (options === void 0) {
+    run.log(USAGE);
+    return MISUSE;
+  }
+  const packageName = await packageNameOf(run.root);
+  const id = options.id ?? siteIdOf(packageName ?? "");
+  const reading = readSiteConfig({
+    id,
+    title: options.title ?? id,
+    cms: options.cms ?? DEFAULT_CMS
+  });
+  if (reading.status === "invalid") {
+    const fields = reading.invalidFields.map((field) => `--${field}`).join(", ");
+    run.log(`Give the site ${fields}.
+
+${USAGE}`);
+    return FAILURE;
+  }
+  const files = await writeSiteFiles(run.root, siteFilesOf(reading.config));
+  for (const path of files.written) run.log(`wrote ${path}`);
+  for (const path of files.kept)
+    run.log(`kept ${path}: the site has it already`);
+  run.log(NEXT_STEPS);
+  return SUCCESS;
+}
+function optionsOf(argv) {
+  try {
+    const { positionals, values } = parseArgs({
+      args: [...argv],
+      allowPositionals: true,
+      options: {
+        id: { type: "string" },
+        title: { type: "string" },
+        cms: { type: "string" }
+      }
+    });
+    const isInit = positionals.length === 1 && positionals[0] === "init";
+    return isInit ? { id: values.id, title: values.title, cms: values.cms } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function packageNameOf(root) {
+  try {
+    const manifest = JSON.parse(
+      await readFile(join2(root, "package.json"), "utf8")
+    );
+    const name = manifest?.name;
+    return typeof name === "string" ? name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/cli.ts
+var code = await runInit({
+  root: process.cwd(),
+  argv: process.argv.slice(2),
+  log: (line) => {
+    console.log(line);
+  }
+});
+process.exitCode = code;

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

@@ -2,14 +2,17 @@ import {
   OWN_PHOTOS_PATH
 } from "./chunk-3BS5CE26.js";
 import {
-  SITE_DESCRIPTION_PATH
-} from "./chunk-NFUGV7JJ.js";
+  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";
@@ -53,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: [
@@ -79,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
               }
             ]
           }
@@ -110,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-UBBVOSON.js";
-import "./chunk-NFUGV7JJ.js";
+} from "./chunk-2E7VDSUK.js";
+import "./chunk-DRDPKFHZ.js";
 export {
   OWN_PHOTOS_PATH,
   PROTOCOL_VERSION,

package/dist/schema.d.ts

@@ -175,4 +175,27 @@ declare function openingHoursField(options?: {
 /** The schema the input describes, or undefined when it is not one. */
 declare function readFields(input: unknown): Fields | undefined;
 
-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, readFields, resolveFieldPath, seoFields, withRecordIds };
+/** 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,7 @@ import {
   REVEALED_ATTRIBUTE,
   REVEAL_ATTRIBUTE,
   REVEAL_EVENT,
+  SITE_CONFIG_FILE,
   SITE_DESCRIPTION_PATH,
   WEEKDAYS,
   asOneParagraph,
@@ -26,6 +27,7 @@ import {
   imagePosition,
   isRecordId,
   isSearchTextsGroup,
+  isSiteId,
   link,
   linkTargetOf,
   newRecord,
@@ -36,6 +38,7 @@ import {
   plainTextOf,
   readFields,
   readRichText,
+  readSiteConfig,
   readSiteDescription,
   reference,
   references,
@@ -48,13 +51,14 @@ import {
   toggle,
   url,
   withRecordIds
-} from "./chunk-NFUGV7JJ.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,
@@ -77,6 +81,7 @@ export {
   imagePosition,
   isRecordId,
   isSearchTextsGroup,
+  isSiteId,
   link,
   linkTargetOf,
   newRecord,
@@ -87,6 +92,7 @@ export {
   plainTextOf,
   readFields,
   readRichText,
+  readSiteConfig,
   readSiteDescription,
   reference,
   references,

package/dist/site.d.ts

@@ -11,11 +11,8 @@ interface SeamletPage {
     /** 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;
-    /** How the CMS names the site: «Кофейня «Зерно»». */
-    readonly title: string;
     readonly schema: F;
     /** The content the site shows, and the CMS edits, until the first publication. */
     readonly initialContent: ContentOf<F>;
@@ -42,9 +39,10 @@ interface SeamletSite<F extends Fields = Fields> {
 /** 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 with this id, 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.
+ * What the CMS published for the site, in the shape of its schema: the site's initial content until
+ * the first publication, and while the CMS does not know the site yet. For a module that needs the
+ * content without the pages.
  */
-declare function loadPublishedContent<F extends Fields>(siteId: string, schema: F): Promise<ContentOf<F>>;
+declare function loadPublishedContent<F extends Fields>(schema: F): Promise<ContentOf<F>>;
 
 export { type SeamletPage, type SeamletSite, type SeamletSiteDefinition, defineSeamletSite, loadPublishedContent };

package/dist/site.js

@@ -1,12 +1,33 @@
 import {
   parseContent
-} from "./chunk-NFUGV7JJ.js";
+} from "./chunk-DRDPKFHZ.js";
 
 // src/site.ts
-import { cmsOrigin } from "virtual:seamlet/config";
+import { cmsOrigin, siteId, siteTitle } from "virtual:seamlet/config";
+
+// src/published-answers.ts
+var NOT_FOUND = 404;
+var UNKNOWN_SITE = "unknown-site";
+async function readPublishedAnswer(response, url) {
+  if (response.ok)
+    return { status: "published", content: await response.json() };
+  const isUnknownSite = response.status === NOT_FOUND && await errorOf(response) === UNKNOWN_SITE;
+  if (isUnknownSite) return { status: "unknown-site" };
+  throw new Error(
+    `Loading the published content from ${url.href} failed with status ${String(response.status)}`
+  );
+}
+async function errorOf(response) {
+  try {
+    const body = await response.json();
+    return typeof body === "object" && body !== null ? body.error : void 0;
+  } catch {
+    return void 0;
+  }
+}
 
 // src/site-descriptions.ts
-function describeSite(definition) {
+function describeSite(identity, definition) {
   const pages = Object.entries(definition.pages).map(
     ([path, page]) => ({
       path,
@@ -16,11 +37,11 @@ function describeSite(definition) {
   );
   const [home, ...rest] = pages;
   if (home === void 0) {
-    throw new Error(`The site "${definition.id}" has no pages`);
+    throw new Error(`The site "${identity.id}" has no pages`);
   }
   return {
-    id: definition.id,
-    title: definition.title,
+    id: identity.id,
+    title: identity.title,
     schema: definition.schema,
     initialContent: definition.initialContent,
     pages: [home, ...rest]
@@ -32,27 +53,26 @@ 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}`)?.component,
-    loadPublishedContent: () => loadPublishedContent(definition.id, definition.schema),
+    loadPublishedContent: () => loadPublishedContent(definition.schema),
     ownPhotoAt: (src) => definition.photos?.(src),
-    description: describeSite(definition)
+    description: describeSite({ id: siteId, title: siteTitle }, definition)
   };
 }
-async function loadPublishedContent(siteId, schema) {
-  const published = await fetchPublished(siteId);
-  return parseContent(schema, published).content;
-}
-async function fetchPublished(siteId) {
+async function loadPublishedContent(schema) {
   const url = new URL(`/api/sites/${siteId}/published`, cmsOrigin);
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(
-      `Loading the published content from ${url.href} failed with status ${String(response.status)}`
-    );
-  }
-  return response.json();
+  const answer = await readPublishedAnswer(await fetch(url), url);
+  const content = answer.status === "published" ? answer.content : await initialContentOfSite();
+  return parseContent(schema, content).content;
+}
+async function initialContentOfSite() {
+  console.warn(
+    `@seamlet/astro: the CMS at ${cmsOrigin} does not know the site "${siteId}" yet; its initial content is shown`
+  );
+  const { default: site } = await import("virtual:seamlet/site");
+  return site.description.initialContent;
 }
 export {
   defineSeamletSite,

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@seamlet/astro",
-  "version": "0.9.0",
+  "version": "0.11.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",
+  "bin": {
+    "seamlet-astro": "./dist/cli.js"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/seamlet/sdk.git",