@marktiderman/genesis-sites 0.0.0-stage → 0.2.0

package/dist/sections.js

@@ -0,0 +1,6 @@
+export { Anchor, ButtonLink, CHIP_TONES, HiddenTitle, ICONS, IconName, ItemTitle, MAP_PROVIDERS, SectionBand, SectionIntro, SectionTitle, SiteFormHeader, SiteImage, TextLink, WEEKDAYS, blogListSection, builtInSections, ctaSection, faqSection, featuresSection, fileDescription, fileHref, fileSection, footerSection, formEmbedSection, formatPostDate, formatTime, gallerySection, heroSection, linkAttrs, logosSection, mapEmbedUrl, mapPageUrl, mapSection, navSection, postBodySection, pricingSection, resolveHref, richTextSection, scheduleSection, siteFormSlots, statsSection, teamSection, testimonialsSection, timelineSection, titleId } from './chunk-C375ZPU2.js';
+import './chunk-VZUDRPFG.js';
+import './chunk-ZGWGQGT2.js';
+import './chunk-3VKTBE7S.js';
+//# sourceMappingURL=sections.js.map
+//# sourceMappingURL=sections.js.map

package/dist/sections.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"sections.js"}

package/dist/store-DkSycDhq.d.ts

@@ -0,0 +1,443 @@
+import { h as FontChoice, a as SiteDoc, A as AnySectionDefinition, N as ReleaseSnapshot, R as ReleasePage, J as Release, r as PageMeta, P as PageDoc, f as PageKind, K as ReleaseMeta, b as PostSummary, L as LivePost, x as PostMeta, w as PostDraft, V as SavePostInput, W as SavePostResult, k as ImportPost, l as ImportPostsResult, e as SiteDocInput, u as PostDoc, z as PostStatus } from './registry-D_DCWRTc.js';
+import { CanonicalBrand } from '@marktiderman/genesis-design-system';
+
+/**
+ * A site's theme, from its brand: one `<style>` of CSS variables per site.
+ *
+ * The brand comes from the host (`BrandSource`) at render time, never copied
+ * into the site. A publish checks the brand's colours and records its hash;
+ * a page rendered with a different brand (edited since) is served with a
+ * short cache and a warning until the site is published again, which checks
+ * the new colours and purges the old pages. It
+ * may be a full `CanonicalBrand` or the minimal shape a brand screen collects
+ * (`SiteBrand`: a name, a primary colour for light and dark, a heading and a
+ * body font from a fixed list, a logo).
+ *
+ * The variables are design-system `themeFromBrand(brand).variables` (the
+ * brand's scales, `--color-*`) plus the genesis-ui roles the sections are
+ * styled with (`--primary`, `--background`, `--font-display`, ...), so the
+ * one shared stylesheet serves every brand. Foregrounds are picked for
+ * contrast: the text on a primary button is whichever of the brand's light
+ * or dark text reads better, and the focus ring falls back to the text
+ * colour when the primary is too faint on the page.
+ */
+
+/** The minimal brand: what a brand screen collects. */
+interface SiteBrand {
+    name: string;
+    colors: {
+        /** The primary colour in light mode, as #rrggbb. */
+        primary: string;
+        /** The primary in dark mode. Default: the light primary, lightened. */
+        primaryDark?: string;
+    };
+    fonts?: {
+        heading?: FontChoice;
+        body?: FontChoice;
+    };
+    /** The logo, shown in the header and footer and named in JSON-LD. */
+    logo?: {
+        src: string;
+        alt?: string;
+    };
+}
+/** What a `BrandSource` may return: the minimal brand, or a full design-system brand (with an optional logo). */
+type BrandInput = SiteBrand | (CanonicalBrand & {
+    logo?: {
+        src: string;
+        alt?: string;
+    };
+    displayName?: string;
+});
+/** The host's brand, read at render time. */
+interface BrandSource {
+    getBrand(siteId: string): Promise<BrandInput | null> | BrandInput | null;
+}
+interface FontInfo {
+    label: string;
+    /** The CSS font stack. */
+    stack: string;
+    /** The Google Fonts `family=` value, when it isn't a system font. */
+    google?: string;
+}
+/** The fonts a brand or site may choose. */
+declare const FONT_CHOICES: Readonly<Record<FontChoice, FontInfo>>;
+/** `#abc` / `#aabbcc` → [r, g, b] (0–255). Throws on anything else. */
+declare function parseHex(hex: string): [number, number, number];
+/** WCAG relative luminance. */
+declare function luminance(hex: string): number;
+/** WCAG contrast ratio (1–21) of two colours. */
+declare function contrastRatio(a: string, b: string): number;
+/** Mix a colour toward white (`amount` > 0) or black (< 0), 0–1. */
+declare function mix(hex: string, amount: number): string;
+/** `#4f46e5` → `243 75% 59%`: the HSL triplet genesis-ui's variables hold. */
+declare function hexToHslTriplet(hex: string): string;
+declare function isSiteBrand(brand: BrandInput): brand is SiteBrand;
+/** The minimal brand as a design-system brand (Genesis's neutrals and status colours, the brand's primary and fonts). */
+declare function toCanonicalBrand(brand: BrandInput): CanonicalBrand;
+/** The brand's display name: the minimal brand's `name`, a canonical brand's `displayName` or `name`. */
+declare function brandDisplayName(brand: BrandInput): string;
+interface ThemePair {
+    /** What the pair is, for an accessibility issue: "body text on the page". */
+    name: string;
+    mode: "light" | "dark";
+    foreground: string;
+    background: string;
+    /** The ratio it must reach: 4.5 for text, 3 for the focus ring and other non-text marks. */
+    minimum: number;
+    /**
+     * `error` (default) blocks the publish; `warning` is shown but doesn't. A
+     * mark that never carries meaning alone (each one also has text or a shape)
+     * warns, so a light brand colour can still publish.
+     */
+    severity?: "error" | "warning";
+}
+interface SiteTheme {
+    light: Record<string, string>;
+    dark: Record<string, string>;
+    colorScheme: "light" | "dark" | "auto";
+    /** The fonts the site uses, to load. */
+    fonts: FontInfo[];
+    /** The colour pairs the sections draw, for the contrast check. */
+    pairs: ThemePair[];
+    /** Hash of the brand and overrides it was made from (recorded on a release). */
+    brandHash: string;
+}
+/** FNV-1a, 32 bits twice: a short, stable hash for cache keys and release records (not for security). */
+declare function stableHash(value: unknown): string;
+/**
+ * The site's theme: variables for light and dark, the fonts to load, the
+ * pairs the contrast check reads, and a hash of what it was made from.
+ *
+ * @stability Beta
+ */
+declare function siteTheme(brand: BrandInput, theme?: Partial<SiteDoc["theme"]>): SiteTheme;
+/** The site's `<style>` body: the light variables on `:root`, the dark ones by scheme. */
+declare function themeCss(theme: SiteTheme): string;
+
+/**
+ * URL and path rules shared by the schemas, the renderer and the database.
+ *
+ * Every link a site renders comes from stored props, so every link is
+ * untrusted. A link is safe when it is a site path (`/about`), a fragment
+ * (`#pricing`), or an absolute `https:`, `http:`, `mailto:` or `tel:` URL.
+ * Everything else (`javascript:`, `data:`, `vbscript:`, protocol-relative
+ * `//host`, a backslash trick, a control character) is refused, both when a
+ * document is parsed and again when it is rendered.
+ */
+/** The longest URL a site stores. */
+declare const MAX_URL_LENGTH = 2048;
+/** Is this a link a site may render: a site path, a fragment, or an http(s), mailto or tel URL? */
+declare function isSafeHref(value: unknown): value is string;
+/** Is this a URL an image may load from: a site path or an `https:` URL? */
+declare function isSafeImageSrc(value: unknown): value is string;
+/** Is this an external (absolute) link, opened with `rel="noopener noreferrer"`? */
+declare function isExternalHref(href: string): boolean;
+/**
+ * A page's path: `/`, or lowercase segments of letters, digits and hyphens
+ * (`/about`, `/classes/strength`). No trailing slash, no dots, at most 8
+ * segments and 200 characters. The database checks the same pattern.
+ */
+declare const PAGE_PATH: RegExp;
+declare const MAX_PAGE_PATH_LENGTH = 200;
+/**
+ * Paths a site never owns, because it shares its hostname with the host app:
+ * the app's API and server functions, its auth callbacks, and this package's
+ * own assets. A host passes its own list (or a predicate) to
+ * `handleSiteRequest` and `validatePagePath`; the database's default is the
+ * same list (`genesis_sites.reserved_paths()`).
+ */
+declare const DEFAULT_RESERVED_PATHS: readonly string[];
+/** A reserved-path rule: a list of path prefixes, or a predicate. */
+type ReservedPaths = readonly string[] | ((path: string) => boolean);
+/** Is `path` reserved: equal to a reserved prefix, or under it (`/api`, `/api/x`, not `/apiary`)? */
+declare function isReservedPath(path: string, reserved?: ReservedPaths): boolean;
+/** Problems with a page path, empty when it is fine. */
+declare function pagePathProblems(path: unknown, reserved?: ReservedPaths): string[];
+/** Throws when the path can't be a page's. */
+declare function validatePagePath(path: string, reserved?: ReservedPaths): string;
+/**
+ * The page path a request path asks for: decoded, lowercase, without a
+ * trailing slash. Returns null for a path that can't name a page (so the
+ * caller falls through to the host app).
+ */
+declare function normalizeRequestPath(pathname: string): string | null;
+
+interface SiteIssue {
+    severity: "error" | "warning";
+    code: string;
+    message: string;
+    pageId?: string;
+    path?: string;
+    sectionId?: string;
+}
+declare const isPublishable: (issues: readonly SiteIssue[]) => boolean;
+type Lookup = (type: string) => AnySectionDefinition | undefined;
+/** Issues on one page: its sections, limits and the h1. */
+declare function checkPage(page: ReleasePage, lookup?: Lookup, reserved?: ReservedPaths): SiteIssue[];
+/** Issues with the site's own parts: header, footer, redirects. */
+declare function checkSiteDoc(site: SiteDoc, lookup?: Lookup): SiteIssue[];
+/** Colour pairs below their minimum (1.4.3 text, 1.4.11 focus ring and primary borders and markers). */
+declare function checkContrast(theme: SiteTheme): SiteIssue[];
+interface CheckReleaseOptions {
+    /** The brand's theme: adds the contrast check. */
+    theme?: SiteTheme;
+    lookup?: Lookup;
+    reserved?: ReservedPaths;
+}
+/**
+ * Everything a publish checks, for a whole release.
+ *
+ * @stability Beta
+ */
+declare function checkRelease(snapshot: ReleaseSnapshot, options?: CheckReleaseOptions): SiteIssue[];
+/** The blog's rules: one post page, not the home page, with a post-body section; a post list needs a post page. */
+declare function checkBlog(snapshot: ReleaseSnapshot, lookup?: Lookup): SiteIssue[];
+/**
+ * The checks a post passes before it is published: a slug, a title, alt
+ * text on its images, and a heading outline under the post's own title
+ * (the page's h1): no level 1 heading, none skipped, starting at 2.
+ *
+ * @stability Beta
+ */
+declare function checkPost(slug: string, doc: unknown): SiteIssue[];
+/**
+ * A rendered page's outline, from its HTML: one `h1`, no skipped heading
+ * level, every `<img>` with an `alt` attribute. For tests and for hosts that
+ * want to audit what was actually served.
+ */
+declare function checkHtmlOutline(html: string): SiteIssue[];
+
+/**
+ * Where sites live: the `SiteStore` contract, the publish pipeline every
+ * store shares, cache invalidation, and an in-memory store for tests, demos
+ * and previews. `@marktiderman/genesis-sites/supabase` has the Postgres one.
+ */
+
+type SaveResult<T> = {
+    rev: number;
+} | {
+    conflict: T;
+    rev: number;
+};
+declare const isConflict: <T>(result: SaveResult<T>) => result is {
+    conflict: T;
+    rev: number;
+};
+/**
+ * The file types a site asset may be, as the database checks them: images
+ * and PDF. Never SVG or HTML, which a browser runs as a page.
+ */
+declare const ASSET_TYPES: readonly string[];
+/**
+ * The storage key for an upload: `sites/<siteId>/<id>-<name>` for an image,
+ * `sites/<siteId>/files/<id>-<name>` for a file to download (a PDF), so
+ * storage policies scope by site with `can_edit`.
+ */
+declare function assetPath(siteId: string, id: string, name: string | undefined, mime: string): string;
+interface AssetMeta {
+    alt?: string;
+    width?: number;
+    height?: number;
+    /** The file's name, for the storage key. */
+    name?: string;
+}
+interface Asset {
+    id: string;
+    siteId: string;
+    /** The storage key: always `sites/<siteId>/...`, so storage policies can scope by site. */
+    path: string;
+    /** Where the browser loads it. */
+    url: string;
+    mime: string;
+    alt: string | null;
+    width: number | null;
+    height: number | null;
+}
+interface PublishOptions {
+    note?: string;
+    /** The brand to check contrast against (and record the hash of). Required: a publish without it is blocked. */
+    brand?: BrandInput | null;
+    reserved?: ReservedPaths;
+}
+interface NewPage {
+    path: string;
+    kind?: PageKind;
+    doc: PageDoc;
+}
+interface SiteDraft {
+    site: SiteDoc;
+    rev: number;
+}
+interface PageDraft {
+    doc: PageDoc;
+    rev: number;
+    siteId: string;
+    path: string;
+    kind: PageKind;
+}
+/**
+ * A site's storage.
+ *
+ * Drafts change by compare-and-swap on a revision: a save names the revision
+ * it started from and gets the new one, or the current document when someone
+ * saved first. A publish checks the drafts (`checkRelease`) and freezes them
+ * into an immutable release that the live site points at; a rollback moves
+ * the pointer back. `getLive` is the public read and needs no session.
+ *
+ * @stability Beta
+ */
+interface SiteStore {
+    /** The release the live site serves, or null (not published, archived, or unknown). */
+    getLive(siteId: string): Promise<Release | null>;
+    getDraft(siteId: string): Promise<SiteDraft | null>;
+    saveSiteDraft(siteId: string, rev: number, site: SiteDoc): Promise<SaveResult<SiteDoc>>;
+    listPages(siteId: string): Promise<PageMeta[]>;
+    getPageDraft(pageId: string): Promise<PageDraft | null>;
+    savePageDraft(pageId: string, rev: number, doc: PageDoc): Promise<SaveResult<PageDoc>>;
+    createPage(siteId: string, page: NewPage): Promise<PageMeta>;
+    /** Move a page to a new path; the old path redirects to it (301). */
+    movePage(pageId: string, path: string): Promise<PageMeta>;
+    deletePage(pageId: string): Promise<void>;
+    publish(siteId: string, options?: PublishOptions): Promise<Release>;
+    rollback(siteId: string, releaseId: string): Promise<Release>;
+    listReleases(siteId: string): Promise<ReleaseMeta[]>;
+    /** Store an upload under `sites/<siteId>/...` (a PDF under `files/`) and record it. Images and PDF only. */
+    putAsset?(siteId: string, file: Blob, meta?: AssetMeta): Promise<Asset>;
+    /** The published posts, newest first, without bodies (at most `MAX_LIVE_POSTS`). Public, like `getLive`. */
+    listLivePosts?(siteId: string): Promise<PostSummary[]>;
+    /** One published post. Public, like `getLive`. Null for a draft, an unknown slug, or a site that isn't live. */
+    getLivePost?(siteId: string, slug: string): Promise<LivePost | null>;
+    /** Every post's meta for the editor (drafts too), newest first. */
+    listPosts?(siteId: string): Promise<PostMeta[]>;
+    getPost?(postId: string): Promise<PostDraft | null>;
+    /** Create a post (no `id`) or save its draft by compare-and-swap. A post keeps its slug once published. */
+    savePost?(siteId: string, input: SavePostInput): Promise<SavePostResult>;
+    /** Check the draft (`checkPost`) and make it the published copy. Throws `PublishBlockedError`. */
+    publishPost?(postId: string): Promise<PostMeta>;
+    /** Take the post down; its draft stays. */
+    unpublishPost?(postId: string): Promise<PostMeta>;
+    /** Delete a post (its row stays, marked deleted). Returns its site, for the cache purge; null when there was no such post. */
+    deletePost?(postId: string): Promise<{
+        siteId: string;
+    } | null>;
+    /**
+     * A one-time import from another site: each post keeps its slug and its
+     * date, and is published unless asked otherwise or a check fails (then it
+     * is a draft, with its issues). A slug the site already has is skipped.
+     */
+    importPosts?(siteId: string, posts: readonly ImportPost[]): Promise<ImportPostsResult>;
+}
+/** A publish the checks refused: `issues` lists why. */
+declare class PublishBlockedError extends Error {
+    readonly issues: SiteIssue[];
+    constructor(issues: SiteIssue[]);
+}
+/** Someone saved first; the store's current document is in the result of the save that raised this. */
+declare class SiteConflictError extends Error {
+    constructor(message?: string);
+}
+interface PreparedRelease {
+    snapshot: ReleaseSnapshot;
+    issues: SiteIssue[];
+    /** Drafts whose props a migration changed: a store saves these before it publishes. */
+    migratedPages: {
+        id: string;
+        doc: PageDoc;
+    }[];
+    migratedSite: SiteDoc | null;
+    brandHash: string | null;
+}
+/**
+ * The publish pipeline every store shares: migrate every node, freeze the
+ * drafts into a snapshot, and check it. Throws `PublishBlockedError` when a
+ * check fails. Pages come in the order they are listed.
+ *
+ * @stability Beta
+ */
+declare function prepareRelease(site: SiteDoc, pages: readonly {
+    id: string;
+    path: string;
+    kind: PageKind;
+    doc: PageDoc;
+}[], options?: PublishOptions): PreparedRelease;
+/** The cache tag every response of a site carries (`Vercel-Cache-Tag`). */
+declare function siteCacheTag(siteId: string): string;
+/** The cache tag of every page that embeds a form: purge it when the host changes that form. */
+declare function formCacheTag(slug: string): string;
+/** Why a site's cache is being purged. */
+interface InvalidationInfo {
+    siteId: string;
+    /** `post`: a post was published, taken down, deleted or imported. */
+    action: "publish" | "rollback" | "post";
+}
+/**
+ * A store that purges the site's cached pages after every publish and
+ * rollback: `invalidate` gets `["site:<id>"]` and what happened.
+ *
+ * Mind what your CDN's purge does. On Vercel, `invalidateByTag` marks pages
+ * stale, so each cached URL serves the old release once more while it
+ * regenerates (no stampede); `dangerouslyDeleteByTag` drops them, so the
+ * next request waits for a render. Use the delete for a rollback that takes
+ * something down:
+ *
+ *   withCacheInvalidation(store, (tags, { action }) =>
+ *     action === "rollback" ? dangerouslyDeleteByTag(tags) : invalidateByTag(tags));
+ *
+ * Archiving a site goes through your own server or the database (the
+ * `genesis_sites` notification), so purge there too. A failed purge is
+ * logged and rethrown, so the editor shows that the live site may be stale.
+ *
+ * @stability Beta
+ */
+declare function withCacheInvalidation(store: SiteStore, invalidate: (tags: string[], info: InvalidationInfo) => Promise<void> | void): SiteStore;
+/**
+ * One post of an import, checked: its document parsed, its status (a draft
+ * when asked for, or when a check fails, with the reasons) and its date.
+ * Every store's `importPosts` runs it.
+ */
+declare function prepareImportPost(item: ImportPost): {
+    doc: PostDoc;
+    status: PostStatus;
+    publishedAt: string;
+    issues: string[];
+} | {
+    slug: string;
+    reason: string;
+};
+interface NewSite {
+    id?: string;
+    /** The site document (defaults applied). */
+    site: SiteDocInput;
+    pages: {
+        id?: string;
+        path: string;
+        kind?: PageKind;
+        doc: PageDoc;
+    }[];
+}
+interface MemorySiteStore extends SiteStore {
+    createSite(input: NewSite): Promise<{
+        siteId: string;
+        pageIds: string[];
+    }>;
+    /** Archive (or bring back) a site: an archived site serves nothing. */
+    setStatus(siteId: string, status: "draft" | "live" | "archived"): Promise<void>;
+}
+interface MemoryStoreOptions {
+    reserved?: ReservedPaths;
+    /** Who may edit (default: everyone). Mirrors the database's `can_edit` hook, for tests. */
+    canEdit?: (siteId: string) => boolean;
+    now?: () => Date;
+}
+/**
+ * An in-memory `SiteStore`: the same rules as the database (compare-and-swap
+ * revisions, path checks, redirects on move, immutable releases), for tests,
+ * demos and local previews. Documents are copied in and out, so callers
+ * can't change stored state by mutating what they hold.
+ *
+ * @stability Beta
+ */
+declare function createMemorySiteStore(options?: MemoryStoreOptions): MemorySiteStore;
+
+export { pagePathProblems as $, ASSET_TYPES as A, type BrandInput as B, type CheckReleaseOptions as C, DEFAULT_RESERVED_PATHS as D, checkSiteDoc as E, FONT_CHOICES as F, contrastRatio as G, createMemorySiteStore as H, type InvalidationInfo as I, formCacheTag as J, hexToHslTriplet as K, isConflict as L, MAX_PAGE_PATH_LENGTH as M, type NewPage as N, isExternalHref as O, PAGE_PATH as P, isPublishable as Q, type ReservedPaths as R, type SiteStore as S, type ThemePair as T, isReservedPath as U, isSafeHref as V, isSafeImageSrc as W, isSiteBrand as X, luminance as Y, mix as Z, normalizeRequestPath as _, type SiteBrand as a, parseHex as a0, prepareImportPost as a1, prepareRelease as a2, siteCacheTag as a3, siteTheme as a4, stableHash as a5, themeCss as a6, toCanonicalBrand as a7, validatePagePath as a8, withCacheInvalidation as a9, type Asset as b, type AssetMeta as c, type BrandSource as d, type FontInfo as e, MAX_URL_LENGTH as f, type MemorySiteStore as g, type MemoryStoreOptions as h, type NewSite as i, type PageDraft as j, type PreparedRelease as k, PublishBlockedError as l, type PublishOptions as m, type SaveResult as n, SiteConflictError as o, type SiteDraft as p, type SiteIssue as q, type SiteTheme as r, assetPath as s, brandDisplayName as t, checkBlog as u, checkContrast as v, checkHtmlOutline as w, checkPage as x, checkPost as y, checkRelease as z };

package/dist/supabase.d.ts

@@ -0,0 +1,41 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { S as SiteStore } from './store-DkSycDhq.js';
+export { A as ASSET_TYPES } from './store-DkSycDhq.js';
+import './registry-D_DCWRTc.js';
+import 'react';
+import 'zod';
+import '@marktiderman/genesis-design-system';
+
+/**
+ * @marktiderman/genesis-sites/supabase: `createSupabaseSiteStore`, the
+ * `SiteStore` over the `genesis_sites` schema (migration
+ * `migrations/0001_genesis_sites.sql`).
+ *
+ * Pass a client signed in as the editor for drafts and publishing (row level
+ * security and `can_edit` / `can_view` decide), or an anonymous one for the
+ * public read (`getLive`, through `genesis_sites.live_release`). The schema
+ * must be exposed to the API.
+ *
+ * @packageDocumentation
+ */
+
+declare const SITES_SCHEMA = "genesis_sites";
+
+interface SupabaseSiteStoreOptions {
+    /** The storage bucket for `putAsset`. Default `site-assets`. */
+    bucket?: string;
+}
+/** A database error with its SQLSTATE (`GS409` a conflict, `42501` not allowed). */
+declare class SiteStoreError extends Error {
+    readonly code: string | undefined;
+    readonly detail?: string | undefined;
+    constructor(message: string, code: string | undefined, detail?: string | undefined);
+}
+/**
+ * A `SiteStore` on Supabase.
+ *
+ * @stability Beta
+ */
+declare function createSupabaseSiteStore(client: SupabaseClient, options?: SupabaseSiteStoreOptions): SiteStore;
+
+export { SITES_SCHEMA, SiteStoreError, type SupabaseSiteStoreOptions, createSupabaseSiteStore };