@marktiderman/genesis-sites 0.1.0 → 0.3.0

package/dist/{registry-CdgVymsu.d.ts → registry-HBn1X60x.d.ts}

@@ -14,13 +14,51 @@ import { z } from 'zod';
 
 /** A link target: a site path, a fragment, or an http(s), mailto or tel URL. */
 declare const Href: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
-/** A labelled link: a button, a menu entry, a footer link. */
+/** An analytics event name for a link: `data-gs-event` on the page (default `cta` on buttons). */
+declare const LinkEvent: z.ZodString;
+/**
+ * A labelled link: a button, a menu entry, a footer link, an outbound
+ * booking link.
+ *
+ * - `external: true` marks a link that leaves the site (a booking or
+ *   membership system): it must be an `http(s)` URL, and it renders with
+ *   `rel="noopener noreferrer"` and `data-gs-outbound` for analytics.
+ * - `target` (`_blank` for a new tab) applies to http(s) links only;
+ *   `newTab: true` is the older spelling of `target: "_blank"`.
+ * - `event` names the click for the host's analytics (`data-gs-event`).
+ */
 declare const Link: z.ZodObject<{
     label: z.ZodString;
     href: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
     newTab: z.ZodOptional<z.ZodBoolean>;
+    target: z.ZodOptional<z.ZodEnum<{
+        _self: "_self";
+        _blank: "_blank";
+    }>>;
+    external: z.ZodOptional<z.ZodBoolean>;
+    event: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type Link = z.infer<typeof Link>;
+/** Does this link open in a new tab? Only an http(s) link can. */
+declare const opensInNewTab: (link: Pick<Link, "href" | "newTab" | "target">) => boolean;
+/**
+ * A downloadable file (a PDF timetable, a waiver): a site path (an upload
+ * under `sites/<site_id>/files/`) or an https URL. `bytes` and `mime` say
+ * what the visitor is about to download.
+ */
+declare const FileRef: z.ZodObject<{
+    src: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+    mime: z.ZodDefault<z.ZodEnum<{
+        "application/pdf": "application/pdf";
+        "image/png": "image/png";
+        "image/jpeg": "image/jpeg";
+        "image/webp": "image/webp";
+        "image/avif": "image/avif";
+        "image/gif": "image/gif";
+    }>>;
+    bytes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type FileRef = z.infer<typeof FileRef>;
 /**
  * An image. `alt` describes it for someone who can't see it; an image that
  * adds nothing (a texture) is `decorative: true` and gets an empty alt. The
@@ -134,9 +172,16 @@ declare const PageDoc: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 type PageDoc = z.infer<typeof PageDoc>;
+/**
+ * What a page is: an ordinary `page`, a focused `landing` page, or the
+ * `post` page: the template every blog post renders in. A site has at most
+ * one post page; at its own path (`/blog`) it is the blog's index, and at
+ * `/blog/<slug>` it shows that post in its `post-body` section.
+ */
 declare const PageKind: z.ZodEnum<{
     page: "page";
     landing: "landing";
+    post: "post";
 }>;
 type PageKind = z.infer<typeof PageKind>;
 declare const PagePath: z.ZodString;
@@ -340,6 +385,7 @@ declare const ReleasePage: z.ZodObject<{
     kind: z.ZodEnum<{
         page: "page";
         landing: "landing";
+        post: "post";
     }>;
     doc: z.ZodObject<{
         schemaVersion: z.ZodLiteral<1>;
@@ -494,6 +540,7 @@ declare const ReleaseSnapshot: z.ZodObject<{
         kind: z.ZodEnum<{
             page: "page";
             landing: "landing";
+            post: "post";
         }>;
         doc: z.ZodObject<{
             schemaVersion: z.ZodLiteral<1>;
@@ -574,10 +621,15 @@ declare const MAX_DOC_BYTES: number;
  * form by its slug; the host says what that slug is, through a resolver
  * passed to the renderer. This package assumes no forms table.
  *
- * - `definition`: a genesis-forms definition. The page renders it on the
- *   server with forms-web's `<Form>`, and the form island makes it
- *   interactive; answers are POSTed as JSON to `submitUrl` (the host's
- *   endpoint, for example one that runs genesis-forms destinations).
+ * - `definition`: a genesis-forms definition, sent to an endpoint. The page
+ *   renders it on the server (a plain HTML form when it needs no engine,
+ *   forms-web's `<Form>` and the form island otherwise), and answers are
+ *   POSTed as JSON (`{ form, answers }`) to `submitUrl`: a site path (the
+ *   host's own endpoint, for example one that runs genesis-forms
+ *   destinations) or an https URL (another service's endpoint).
+ * - `mailto`: no form at all, a button that opens the visitor's email to
+ *   `email`. The fallback for a site with no endpoint yet: nothing is
+ *   stored, and a page never posts a form to `mailto:`.
  * - `embed`: an https URL the page shows in an iframe (a hosted form).
  */
 type ResolvedForm = {
@@ -588,6 +640,16 @@ type ResolvedForm = {
     submitUrl: string;
     layout?: "classic" | "focus";
     submitLabel?: string;
+} | {
+    kind: "mailto";
+    /** The address the button writes to. */
+    email: string;
+    /** The email's subject line. */
+    subject?: string;
+    /** The button's label (default "Email us"). */
+    label?: string;
+    /** A line above the button. */
+    note?: string;
 } | {
     kind: "embed";
     /** An https URL. */
@@ -604,6 +666,188 @@ interface FormsResolverContext {
 }
 /** slug → the form to show, or null when the host has no such form (the section then renders nothing and logs). */
 type FormsResolver = (slug: string, ctx: FormsResolverContext) => ResolvedForm | null | Promise<ResolvedForm | null>;
+/** A plain email address (no display name, no `%` escapes, no header injection): what a `mailto` form may write to. */
+declare function isPlainEmail(value: unknown): value is string;
+/** The `mailto:` link for a mailto form, or null when its address isn't a plain one. */
+declare function mailtoHref(form: Extract<ResolvedForm, {
+    kind: "mailto";
+}>): string | null;
+
+/**
+ * Blog posts: a site's collection of dated articles.
+ *
+ * A post is its own document (`PostDoc`), kept beside the pages rather than
+ * in them, with a draft and a published copy. `publishPost` checks the draft
+ * and copies it to the published copy; that copy is what visitors see, so
+ * a post goes live (and comes down) on its own, without republishing the
+ * site. The site's `post` page is the template every post renders in: at its
+ * own path it is the blog's index, and at `<path>/<slug>` it shows the post.
+ */
+
+/** A post's slug: lowercase letters, digits and single hyphens (`september-testing`). */
+declare const PostSlug: z.ZodString;
+declare const PostAuthor: z.ZodObject<{
+    name: z.ZodString;
+    url: z.ZodOptional<z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>;
+}, z.core.$strip>;
+declare const PostDoc: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    title: z.ZodString;
+    excerpt: z.ZodOptional<z.ZodString>;
+    body: z.ZodObject<{
+        type: z.ZodLiteral<"doc">;
+        content: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip>;
+    cover: z.ZodOptional<z.ZodObject<{
+        src: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+        alt: z.ZodDefault<z.ZodString>;
+        decorative: z.ZodOptional<z.ZodBoolean>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+        focal: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    author: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodOptional<z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>;
+    }, z.core.$strip>>;
+    category: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    seo: z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ogImage: z.ZodOptional<z.ZodObject<{
+            src: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+            alt: z.ZodDefault<z.ZodString>;
+            decorative: z.ZodOptional<z.ZodBoolean>;
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+            focal: z.ZodOptional<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        canonical: z.ZodOptional<z.ZodURL>;
+        noindex: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type PostDoc = z.infer<typeof PostDoc>;
+type PostDocInput = z.input<typeof PostDoc>;
+type PostStatus = "draft" | "published";
+/** A post as the editor lists it. */
+interface PostMeta {
+    id: string;
+    siteId: string;
+    slug: string;
+    title: string;
+    status: PostStatus;
+    /** The draft's revision, for compare-and-swap saves. */
+    rev: number;
+    /** When it was first published (kept when it is published again), or null. */
+    publishedAt: string | null;
+    updatedAt: string;
+}
+/** A post's draft, for the editor. */
+interface PostDraft extends PostMeta {
+    doc: PostDoc;
+}
+/** A published post, as visitors see it. */
+interface LivePost {
+    slug: string;
+    publishedAt: string;
+    /** When its published copy last changed. */
+    updatedAt: string;
+    doc: PostDoc;
+}
+/** A published post in a list: everything but the body. */
+interface PostSummary {
+    slug: string;
+    title: string;
+    excerpt?: string;
+    cover?: Image;
+    author?: z.infer<typeof PostAuthor>;
+    category?: string;
+    /** Kept out of the sitemap and the feed (`seo.noindex`, or a canonical elsewhere). */
+    noindex?: boolean;
+    publishedAt: string;
+    updatedAt: string;
+}
+/** A list item as a store returns it, checked: a stored row that skipped the checks is left out. */
+declare const PostSummarySchema: z.ZodObject<{
+    slug: z.ZodString;
+    title: z.ZodString;
+    excerpt: z.ZodOptional<z.ZodString>;
+    cover: z.ZodOptional<z.ZodObject<{
+        src: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+        alt: z.ZodDefault<z.ZodString>;
+        decorative: z.ZodOptional<z.ZodBoolean>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+        focal: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    author: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodOptional<z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>;
+    }, z.core.$strip>>;
+    category: z.ZodOptional<z.ZodString>;
+    noindex: z.ZodOptional<z.ZodBoolean>;
+    publishedAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+/** The most posts a list reads (the newest first). */
+declare const MAX_LIVE_POSTS = 500;
+/** A save of a post: a new one (no `id`), or a compare-and-swap of an existing one's draft. */
+interface SavePostInput {
+    id?: string;
+    slug: string;
+    /** The draft revision this save started from (required with `id`). */
+    rev?: number;
+    doc: PostDocInput;
+}
+type SavePostResult = {
+    id: string;
+    rev: number;
+} | {
+    id: string;
+    conflict: PostDoc;
+    rev: number;
+};
+/** One post to import (a move from another site): published as of `publishedAt` unless it fails a check. */
+interface ImportPost {
+    slug: string;
+    doc: PostDocInput;
+    /** When it was first published, kept from the old site (default: now). */
+    publishedAt?: string;
+    /** `draft` imports it unpublished. Default `published`. */
+    status?: PostStatus;
+}
+interface ImportPostsResult {
+    /** Imported posts: published, or a draft when asked for or when a check failed (see `issues`). */
+    imported: {
+        slug: string;
+        id: string;
+        status: PostStatus;
+        issues?: string[];
+    }[];
+    /** Posts left out: a slug the site already has, or a document that doesn't parse. */
+    skipped: {
+        slug: string;
+        reason: string;
+    }[];
+}
+/** The most posts one `importPosts` call takes. */
+declare const MAX_IMPORT_POSTS = 500;
+/** A published post as a list item. */
+declare function postSummary(post: LivePost): PostSummary;
+/** Plain text of a rich text document (for a feed's description when a post has no excerpt). */
+declare function richTextPlain(value: unknown, max?: number): string;
+/** Validate a post slug, throwing with a readable message. */
+declare function validatePostSlug(slug: string): string;
 
 /**
  * Sections: `defineSection` describes one kind of section (its props schema,
@@ -660,6 +904,20 @@ interface RenderContext {
     mode: "live" | "preview";
     /** A prefix that makes ids unique on the page: the section node's id. */
     idPrefix: string;
+    /**
+     * The site's blog, when it has a post page: its path, the published posts
+     * (newest first, without bodies), the post this page shows (on
+     * `<path>/<slug>`), and the list's page number (`?page=`).
+     */
+    posts?: PostsContext;
+}
+interface PostsContext {
+    /** The post page's path (`/blog`): posts live at `<path>/<slug>`. */
+    path: string;
+    list: readonly PostSummary[];
+    current: LivePost | null;
+    /** The list's page, from `?page=` (1 when absent). */
+    page: number;
 }
 interface SectionRenderProps<P> {
     props: P;
@@ -694,7 +952,15 @@ interface SectionDefinition<P = Record<string, unknown>> {
      * the renderer, and a publish writes the result into the release.
      */
     migrations?: Readonly<Record<number, (props: Record<string, unknown>) => Record<string, unknown>>>;
-    /** Server-safe React: no state, no effects, no browser APIs. */
+    /**
+     * The https origins this section frames (a map), so the page's
+     * Content-Security-Policy allows them in `frame-src`. Only origins the
+     * section builds itself, never a URL an editor typed.
+     */
+    frameOrigins?: (props: P) => readonly string[];
+    /** It needs the islands loader (a click-to-load map, say). */
+    islands?: boolean;
+    /** Server-safe React: no state, no effects, no browser APIs. Returning null gives the page's h1 back. */
     render: (input: SectionRenderProps<P>) => ReactNode;
 }
 /** A definition as the registry holds it: props erased to a record. */
@@ -711,7 +977,7 @@ declare class SectionDefinitionError extends Error {
  */
 declare function defineSection<P>(def: SectionDefinition<P>): Readonly<SectionDefinition<P>>;
 /** The built-in section kinds, which a host replaces only with `{ replace: true }`. */
-declare const BUILT_IN_SECTION_TYPES: readonly ["nav", "hero", "features", "cta", "testimonials", "faq", "pricing", "logos", "stats", "gallery", "rich-text", "form-embed", "footer"];
+declare const BUILT_IN_SECTION_TYPES: readonly ["nav", "hero", "features", "cta", "testimonials", "faq", "pricing", "logos", "stats", "gallery", "rich-text", "form-embed", "footer", "schedule", "team", "blog-list", "post-body", "map", "timeline", "file"];
 type BuiltInSectionType = (typeof BUILT_IN_SECTION_TYPES)[number];
 interface RegisterSectionOptions {
     /** Replace a built-in kind, for every site in this process. */
@@ -761,4 +1027,4 @@ declare function newSectionId(prefix?: string): string;
 /** A section node from a preset: the editor's Add, and templates. */
 declare function nodeFromPreset(type: string, presetName?: string, id?: string): SectionNode;
 
-export { unregisterSection as $, type AnySectionDefinition as A, BUILT_IN_SECTION_TYPES as B, Copy as C, type SectionRenderProps as D, type SectionVariant as E, FontChoice as F, Seo as G, Href as H, Image as I, SeoDefaults as J, Surface as K, Link as L, MAX_DOC_BYTES as M, defineSection as N, getSection as O, PageDoc as P, listSections as Q, ReleasePage as R, SectionNode as S, TokenOverrides as T, newSectionId as U, nodeFromPreset as V, parseSnapshot as W, registerBuiltInSection as X, registerSection as Y, sectionJsonSchema as Z, sectionManifests as _, SiteDoc as a, Redirect as b, type SiteDocInput as c, PageKind as d, type BuiltInSectionType as e, type FormsResolver as f, type FormsResolverContext as g, Line as h, MenuItem as i, type PageMeta as j, PagePath as k, type RegisterSectionOptions as l, type Release as m, type ReleaseMeta as n, ReleaseSnapshot as o, type RenderContext as p, type ResolvedForm as q, RichText as r, SECTION_CATEGORIES as s, type SectionCategory as t, type SectionDefinition as u, SectionDefinitionError as v, SectionId as w, type SectionManifest as x, type SectionPlacement as y, type SectionPreset as z };
+export { SectionId as $, type AnySectionDefinition as A, BUILT_IN_SECTION_TYPES as B, Copy as C, type PostDocInput as D, type PostDraft as E, type FormsResolver as F, type PostMeta as G, Href as H, Image as I, PostSlug as J, type PostStatus as K, type LivePost as L, MAX_DOC_BYTES as M, PostSummarySchema as N, type PostsContext as O, PageKind as P, type RegisterSectionOptions as Q, type Release as R, type SectionCategory as S, type ReleaseMeta as T, ReleaseSnapshot as U, RichText as V, SECTION_CATEGORIES as W, type SavePostInput as X, type SavePostResult as Y, type SectionDefinition as Z, SectionDefinitionError as _, PageDoc as a, type SectionManifest as a0, type SectionPlacement as a1, type SectionPreset as a2, type SectionRenderProps as a3, type SectionVariant as a4, SeoDefaults as a5, Surface as a6, TokenOverrides as a7, defineSection as a8, getSection as a9, isPlainEmail as aa, listSections as ab, mailtoHref as ac, newSectionId as ad, nodeFromPreset as ae, opensInNewTab as af, parseSnapshot as ag, postSummary as ah, registerBuiltInSection as ai, registerSection as aj, richTextPlain as ak, sectionJsonSchema as al, sectionManifests as am, unregisterSection as an, validatePostSlug as ao, type PageMeta as b, type RenderContext as c, type ResolvedForm as d, Seo as e, SectionNode as f, SiteDoc as g, ReleasePage as h, type PostSummary as i, Redirect as j, Link as k, type SiteDocInput as l, type BuiltInSectionType as m, FileRef as n, FontChoice as o, type FormsResolverContext as p, type ImportPost as q, type ImportPostsResult as r, Line as s, LinkEvent as t, MAX_IMPORT_POSTS as u, MAX_LIVE_POSTS as v, MenuItem as w, PagePath as x, PostAuthor as y, PostDoc as z };