@the-smithy/create-hearth-site 0.0.0-stage → 0.13.0

package/LICENSE

@@ -0,0 +1,17 @@
+Copyright (c) The Smithy. All rights reserved.
+
+This package is published publicly so it can be installed easily. Publishing it does not make it open source.
+
+You may install and use this package, and modify copies of it, only to build, run and maintain software that
+works with The Smithy's services (Hearth and Ember), and only under an active account with those services.
+You may include it in the software you build for that purpose and distribute it as part of that software.
+
+You may not use this package, or any part of it, to build or operate a product or service that competes with
+The Smithy's services, and you may not distribute it on its own.
+
+THE PACKAGE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+SMITHY BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE PACKAGE OR THE USE OF OR OTHER DEALINGS IN THE PACKAGE.
+
+Questions about licensing: hello@thesmithy.io

package/README.md

@@ -1,3 +1,37 @@
-# Temporary Holding Version
+# @the-smithy/create-hearth-site
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Starts a new website powered by [Hearth](https://hearth.thesmithy.io), The Smithy's headless CMS: a Next.js
+site with every content block rendered, SEO, forms, live preview and the publish webhook, ready to restyle.
+
+**It needs API access to Hearth.** The site reads all of its content from a Hearth site with that site's API
+key, so it shows nothing without a Hearth account. Developer access is by invitation: request it at
+[hearth.thesmithy.io/developers](https://hearth.thesmithy.io/developers).
+
+## Getting started
+
+```sh
+pnpm create @the-smithy/hearth-site my-site --site <your-site>
+cd my-site
+```
+
+Put a Delivery API key from your site in Hearth (Settings → Developers) in `.env.local`, then:
+
+```sh
+pnpm dev
+```
+
+| Option | |
+| --- | --- |
+| `<directory>` | The folder to create |
+| `--site <slug>` | Your site's address in Hearth. You're asked for it if left out |
+| `--skip-install` | Don't run `pnpm install` |
+
+The new site's README covers local development and deploying.
+
+## Documentation
+
+Once you have developer access, the full documentation is in your Hearth account under **API docs**.
+
+## License
+
+For use with Hearth. See [LICENSE](./LICENSE).

package/bin/create-hearth-site.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+/*
+ * pnpm create @the-smithy/hearth-site <directory> [--site <slug>] [--skip-install]
+ *
+ * Copies the template next to this file into a new directory, names it, points it at
+ * the matching SDK version, and installs. No network calls besides `pnpm install`.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync, readdirSync, realpathSync } from "node:fs";
+import { cp, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const templateDir = path.join(here, "..", "template");
+const self = JSON.parse(await readFile(path.join(here, "..", "package.json"), "utf8"));
+
+/** Files that exist in the template folder during development but never belong in a new site. */
+// The template's lockfile is the Hearth workspace's (the SDK as a workspace link); a new site makes its own.
+const SKIP = new Set(["node_modules", ".next", ".netlify", ".env.local", "next-env.d.ts", "tsconfig.tsbuildinfo", "pnpm-lock.yaml"]);
+/** Dotfiles npm won't publish (or that would confuse the monorepo) are stored with a leading underscore. */
+const RENAMES = { _gitignore: ".gitignore", "_pnpm-workspace.yaml": "pnpm-workspace.yaml" };
+
+const usage = `Usage: pnpm create @the-smithy/hearth-site <directory> [--site <slug>] [--skip-install]
+
+  <directory>      Folder to create (must be new or empty)
+  --site <slug>    The site's address in Hearth (Site settings), e.g. acme
+  --skip-install   Don't run pnpm install`;
+
+export function packageName(dir) {
+  return (
+    path
+      .basename(path.resolve(dir))
+      .toLowerCase()
+      .replace(/[^a-z0-9-~._]+/g, "-")
+      .replace(/^[-._]+|-+$/g, "") || "hearth-site"
+  );
+}
+
+export const validSlug = (slug) => /^[a-z0-9]+(-[a-z0-9]+)*$/.test(slug);
+
+async function main() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: { site: { type: "string" }, "skip-install": { type: "boolean" }, help: { type: "boolean", short: "h" } },
+  });
+  if (values.help) return console.log(usage);
+
+  let dir = positionals[0];
+  let site = values.site;
+  if ((!dir || !site) && process.stdin.isTTY) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    dir ||= (await rl.question("Folder for the new site: ")).trim();
+    site ||= (await rl.question("Site address in Hearth (e.g. acme): ")).trim();
+    rl.close();
+  }
+  if (!dir) {
+    console.error(usage);
+    process.exit(1);
+  }
+  if (site && !validSlug(site)) {
+    console.error(`"${site}" isn't a Hearth site address: use lowercase letters, numbers and dashes.`);
+    process.exit(1);
+  }
+
+  const target = path.resolve(dir);
+  if (existsSync(target) && readdirSync(target).length > 0) {
+    console.error(`${dir} already exists and isn't empty.`);
+    process.exit(1);
+  }
+
+  await cp(templateDir, target, { recursive: true, filter: (src) => !SKIP.has(path.basename(src)) });
+  for (const [from, to] of Object.entries(RENAMES)) {
+    if (existsSync(path.join(target, from))) await rename(path.join(target, from), path.join(target, to));
+  }
+
+  // Name the project and pin the SDK to the version released alongside this template.
+  const pkgPath = path.join(target, "package.json");
+  const pkg = JSON.parse(await readFile(pkgPath, "utf8"));
+  pkg.name = packageName(dir);
+  for (const deps of [pkg.dependencies, pkg.devDependencies]) {
+    for (const [name, range] of Object.entries(deps ?? {})) {
+      if (typeof range === "string" && range.startsWith("workspace:")) deps[name] = `^${self.version}`;
+    }
+  }
+  await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+
+  const env = (await readFile(path.join(target, ".env.example"), "utf8")).replace(/^HEARTH_SITE=.*$/m, `HEARTH_SITE=${site ?? ""}`);
+  await writeFile(path.join(target, ".env.local"), env);
+
+  if (spawnSync("git", ["--version"], { stdio: "ignore" }).status === 0) {
+    spawnSync("git", ["init", "-q", "-b", "main"], { cwd: target, stdio: "ignore" });
+  }
+
+  let installed = false;
+  if (!values["skip-install"]) {
+    console.log("\nInstalling…");
+    installed = spawnSync("pnpm", ["install"], { cwd: target, stdio: "inherit", shell: process.platform === "win32" }).status === 0;
+    if (!installed) console.warn("\nInstall failed. Fix the error above, then run pnpm install in the new folder.");
+  }
+
+  const rel = path.relative(process.cwd(), target) || ".";
+  console.log(`
+Created ${pkg.name} in ${rel}.
+
+Next:
+  cd ${rel}
+${installed ? "" : "  pnpm install\n"}  Add the site's API key to .env.local (Hearth → the site → Settings → Developers)
+  pnpm dev
+
+README.md covers deploying to Netlify and the publish webhook.`);
+}
+
+// Run when executed (pnpm create runs it through a symlink), not when imported by tests.
+const invoked = process.argv[1] && realpathSync(process.argv[1]);
+if (invoked && invoked === realpathSync(fileURLToPath(import.meta.url))) {
+  await main();
+}

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "@the-smithy/create-hearth-site",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.13.0",
+  "description": "Start a new client website powered by Hearth: pnpm create @the-smithy/hearth-site",
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/The-Smithy/hearth.git",
+    "directory": "packages/create-hearth-site"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "create-hearth-site": "./bin/create-hearth-site.js"
+  },
+  "files": [
+    "bin",
+    "template",
+    "!template/node_modules",
+    "!template/.next",
+    "!template/.netlify",
+    "!template/.env.local",
+    "!template/next-env.d.ts",
+    "!template/tsconfig.tsbuildinfo",
+    "!template/pnpm-lock.yaml",
+    "README.md"
+  ],
+  "devDependencies": {
+    "vitest": "^5.0.3",
+    "@the-smithy/hearth-schema": "^0.13.0"
+  },
+  "scripts": {
+    "test": "node --test \"test/**/*.test.js\" && vitest run test/blocks.test.ts"
+  }
 }

package/template/.env.example

@@ -0,0 +1,8 @@
+# The site's address in Hearth (shown in the admin's site switcher and URLs).
+HEARTH_SITE=
+# A Delivery API key (Hearth → Settings → Developers). Secret: server-side only.
+HEARTH_API_KEY=
+# Signing secret for the revalidation webhook (Hearth → Settings → Developers).
+HEARTH_WEBHOOK_SECRET=
+# Optional: point at a different Hearth (e.g. a staging deploy).
+# HEARTH_BASE_URL=https://hearth.thesmithy.io

package/template/CLAUDE.md

@@ -0,0 +1,37 @@
+# Notes for Claude
+
+This is a client website whose content comes from Hearth, The Smithy's headless CMS. Read
+`node_modules/@the-smithy/hearth/llms.md` for the SDK reference before changing data fetching.
+
+## Rules
+
+- **Content comes from Hearth.** Don't hard-code page text, menus, contact details or SEO tags. They're edited
+  in Hearth and arrive through `src/lib/hearth.ts`. The code owns design and layout.
+- **The API key is secret.** Only import `@/lib/hearth` from server components, route handlers and server
+  actions. Never from a `"use client"` file.
+- **Use `hearthNext.*` for reads.** It caches and tags requests so the publish webhook can refresh them.
+  Calling `hearth.*` directly skips the cache.
+- **Blocks are `{ id, type, data }`.** Each block type has one component in `src/components/blocks/`, typed
+  with `BlockOf<"type">`. Keep them working for every option the block offers: tones, image positions,
+  optional fields left empty.
+- **Styling uses the tokens in `src/app/globals.css`** (`bg-accent`, `text-highlight`, …). Tones are semantic.
+  Check text contrast on every ground.
+- **No bundled content.** Every page comes from Hearth; an address with no published page is a 404. Don't add
+  fallback or sample content to the code.
+- **Previews come from the SDK.** `<HearthPreview />` in the root layout shows drafts and refreshes as editors
+  work in Hearth. Don't build a preview banner of your own.
+- **Forms** post through `submitHearthForm` in `src/app/actions.ts`. Keep the hidden `_gotcha` field.
+
+## Checks
+
+`pnpm typecheck` and `pnpm build`. The build needs the `.env.local` keys, because it reads content from Hearth.
+
+<!-- BEGIN:nextjs-agent-rules -->
+
+# This is NOT the Next.js you know
+
+This version has breaking changes — APIs, conventions, and file structure may all differ from your training data. Read the relevant guide in `node_modules/next/dist/docs/` (resolved from this file's directory; in monorepos the `next` package may not be visible from the repo root) before writing any code. Heed deprecation notices.
+
+This block is written and re-added by `next dev` — verify at `node_modules/next/dist/server/lib/generate-agent-files.js`. Removing it from a diff only re-creates the uncommitted change; committing it with your work keeps the tree clean.
+
+<!-- END:nextjs-agent-rules -->

package/template/README.md

@@ -0,0 +1,68 @@
+# Website powered by Hearth
+
+A Next.js site whose content (pages, menu, footer, events and forms) is managed in
+[Hearth](https://hearth.thesmithy.io). The code decides how things look. Hearth decides what's on the page.
+
+## Setup
+
+1. **Keys.** Copy `.env.example` to `.env.local` (the setup command already did, with `HEARTH_SITE` filled
+   in) and fill it in from the site's Settings → Developers page in Hearth:
+   - `HEARTH_SITE`: the site's address
+   - `HEARTH_API_KEY`: create one under Settings → Developers
+   - `HEARTH_WEBHOOK_SECRET`: from Revalidation webhook (only needed once the site is deployed)
+2. `pnpm install`, then `pnpm dev`.
+3. **Content.** Everything on the site comes from Hearth. Create and publish the homepage there (address
+   `home`), then the other pages. Until a page is published, its address shows "Page not found".
+
+The full documentation (API, SDK, blocks) is in Hearth under **API docs**, with a Markdown version to give an
+AI coding assistant.
+
+## Developing locally
+
+- **Seeing published changes.** Content is cached, and Hearth's publish webhook can't reach your computer. After
+  publishing, do a hard refresh (Ctrl+Shift+R, or Cmd+Shift+R on a Mac): in `pnpm dev` it fetches fresh content.
+- **Previewing drafts.** In Hearth, set Settings → Developers → Preview address to
+  `http://localhost:3000/api/preview`. "Preview on the website" then opens your local site in draft mode, and
+  the page refreshes as you edit. Set it back to the live address once the site is deployed.
+
+## How it fits together
+
+| Where | What |
+| --- | --- |
+| `src/lib/hearth.ts` | The Hearth client. Server-side only, because the key is secret |
+| `src/app/[[...slug]]/page.tsx` | Every page in Hearth at its path (`home` is `/`) |
+| `src/app/events/` | Event list and detail pages (sites with the Events feature) |
+| `src/components/blocks/` | One component per Hearth block type. This is where the design lives |
+| `src/app/globals.css` | Brand tokens: colors, font, content width |
+| `src/app/api/revalidate/route.ts` | Hearth calls this on publish, so changes go live in seconds |
+| `src/components/RegistrationForm.tsx`, `src/app/registered/` | On-site event registration (sites with Tickets): the form on an event's page and the page paid buyers return to |
+| `src/app/fundraisers/`, `src/app/donate/` | Fundraisers and donations (sites with Giving): lists, a fundraiser's page with its donation form, a general donate page and the thank-you page |
+| `src/app/api/preview/route.ts` | Opens drafts from Hearth's "Preview on the website" button (draft mode); `/api/preview/exit` ends it |
+| `<HearthPreview />` in `src/app/layout.tsx` | The SDK's live preview: while an editor previews, the page refreshes as they edit in Hearth |
+| `src/app/sitemap.ts`, `robots.ts` | Generated from Hearth. Search engines stay out until the domain is set |
+
+Page titles, descriptions, canonical URLs, share images and structured data all come from Hearth's SEO
+settings. Nothing to wire up per page.
+
+## Making it the client's own
+
+- Start with the tokens in `globals.css`, then restyle the block components.
+- Headings can mark words with `*asterisks*` to highlight them (see `Emphasis` in `components/ui.tsx`).
+- Every block uses semantic tones (`default`, `muted`, `inverse`, `accent`). Map them to the brand rather than
+  hard-coding colors in a block.
+- To leave a block type out, delete its line in `components/blocks/index.tsx`, and turn it off for the site in
+  Hearth.
+
+## Deploying to Netlify
+
+1. Create the Netlify site from this repo. `netlify.toml` already sets the build.
+2. Add the environment variables `HEARTH_SITE`, `HEARTH_API_KEY` and `HEARTH_WEBHOOK_SECRET`. The packages
+   come from npm, so the build needs no other credentials.
+3. In Hearth, set the site's domain, then set the webhook URL to `https://<domain>/api/revalidate`.
+
+Content is cached and refreshed by the webhook on publish, with an hourly refresh as a safety net.
+
+## Updating the SDK
+
+`pnpm up @the-smithy/hearth`. New block types show up as typed additions. Add a component for them when the
+site needs them.

package/template/_gitignore

@@ -0,0 +1,11 @@
+node_modules/
+/.next/
+/out/
+.netlify
+.DS_Store
+*.tsbuildinfo
+next-env.d.ts
+
+# Keys live here locally and in Netlify's environment variables, never in git.
+.env*
+!.env.example

package/template/_pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+allowBuilds:
+  sharp: true

package/template/netlify.toml

@@ -0,0 +1,6 @@
+[build]
+  command = "pnpm build"
+  publish = ".next"
+
+[build.environment]
+  NODE_VERSION = "22"

package/template/next.config.ts

@@ -0,0 +1,27 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import type { NextConfig } from "next";
+
+const securityHeaders = [
+  { key: "X-Content-Type-Options", value: "nosniff" },
+  { key: "Referrer-Policy", value: "strict-origin-when-cross-origin" },
+  { key: "X-Frame-Options", value: "SAMEORIGIN" },
+  { key: "Permissions-Policy", value: "camera=(), microphone=(), geolocation=()" },
+];
+
+// The site's own folder is the project root, so Next.js never picks up files from a parent folder (another app's
+// proxy or pages). The one exception is this template inside the Hearth repo, where the SDK it uses lives in a
+// sibling folder: there the root is packages/.
+const inHearthRepo = existsSync(path.join(__dirname, "../../sdk/package.json"));
+const root = inHearthRepo ? path.join(__dirname, "../..") : __dirname;
+
+const nextConfig: NextConfig = {
+  poweredByHeader: false,
+  turbopack: { root },
+  outputFileTracingRoot: root,
+  async headers() {
+    return [{ source: "/:path*", headers: securityHeaders }];
+  },
+};
+
+export default nextConfig;

package/template/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "hearth-site-template",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@the-smithy/ember": "^0.3.1",
+    "@the-smithy/hearth": "workspace:^",
+    "next": "16.3.8",
+    "react": "19.2.8",
+    "react-dom": "19.2.8",
+    "react-markdown": "^10.1.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4",
+    "@types/node": "^22",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "tailwindcss": "^4",
+    "typescript": "^5"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "packageManager": "pnpm@11.10.0"
+}

package/template/postcss.config.mjs

@@ -0,0 +1,3 @@
+const config = { plugins: { "@tailwindcss/postcss": {} } };
+
+export default config;

package/template/src/app/[[...slug]]/page.tsx

@@ -0,0 +1,54 @@
+import { normalizeSlug } from "@the-smithy/hearth";
+import { metadataFromMeta } from "@the-smithy/hearth/next";
+import { JsonLd } from "@the-smithy/hearth/react";
+import type { Metadata } from "next";
+import { notFound } from "next/navigation";
+import { Blocks } from "@/components/blocks";
+import { EventView } from "@/components/EventView";
+import { hearthNext } from "@/lib/hearth";
+import { hasFeature } from "@/lib/site";
+
+type Props = { params: Promise<{ slug?: string[] }> };
+
+/**
+ * An event in an event collection, e.g. /talks/<event> for a "Talks" collection. Pages are checked first,
+ * so a page at the same address wins.
+ */
+async function collectionEvent(slug: string[] | undefined) {
+  if (!slug || slug.length < 2) return null;
+  const site = await hearthNext.getSite();
+  if (!hasFeature(site, "events")) return null;
+  const prefix = normalizeSlug(slug.slice(0, -1));
+  const collection = (await hearthNext.getCollections()).find((c) => c.kind === "events" && c.slug === prefix);
+  if (!collection) return null;
+  const event = await hearthNext.getEvent(normalizeSlug(slug.at(-1)));
+  return event?.collection?.id === collection.id ? event : null;
+}
+
+/** Every page in Hearth at its path ("/" is "home", "/about" is "about", "/blog/post" is a blog entry), plus events in collections. */
+export default async function Page({ params }: Props) {
+  const slug = (await params).slug;
+  const page = await hearthNext.getPage(slug);
+  if (page) {
+    return (
+      <>
+        <JsonLd data={page.meta.jsonLd} />
+        {/* Pages usually open with a Hero (the visible title); this keeps a heading for the rest. */}
+        {page.blocks[0]?.type === "hero" ? null : <h1 className="sr-only">{page.title}</h1>}
+        <Blocks blocks={page.blocks} />
+      </>
+    );
+  }
+
+  const event = await collectionEvent(slug);
+  if (event) return <EventView event={event} />;
+  notFound();
+}
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const slug = (await params).slug;
+  const metadata = await hearthNext.generatePageMetadata(slug);
+  if (Object.keys(metadata).length) return metadata;
+  const event = await collectionEvent(slug);
+  return event ? metadataFromMeta(event.meta) : {};
+}

package/template/src/app/actions.ts

@@ -0,0 +1,43 @@
+"use server";
+
+import type { FormResult } from "@the-smithy/hearth";
+import { hearthNext } from "@/lib/hearth";
+
+export type FormState = {
+  ok?: boolean;
+  message?: string;
+  fieldErrors?: Record<string, string>;
+  /** What the visitor typed, so the form keeps it after an error. */
+  values?: Record<string, string>;
+};
+
+/**
+ * Sends a Hearth form block's submission. Submissions land in the site's Forms inbox in Hearth,
+ * which also emails whoever the form notifies. Bots that fill the hidden `_gotcha` field are dropped there.
+ */
+export async function submitHearthForm(formKey: string, _prev: FormState, formData: FormData): Promise<FormState> {
+  const values = Object.fromEntries([...formData.entries()].filter(([k, v]) => typeof v === "string" && !k.startsWith("$") && k !== "_gotcha")) as Record<string, string>;
+  try {
+    const result = await hearthNext.submitForm(formKey, formData);
+    return result.ok ? { ok: true, message: result.message } : { message: result.message, fieldErrors: result.fieldErrors, values };
+  } catch (err) {
+    console.error("[hearth] form submission failed", err);
+    return { message: "Something went wrong sending your message. Please try again.", values };
+  }
+}
+
+/**
+ * Starts a donation (sites with Giving): Hearth checks the amount, records it and returns the payment page, where
+ * the donor is sent. Afterwards the payment provider brings them back to /donate/thank-you.
+ */
+export async function donate(prev: FormResult | null, formData: FormData): Promise<FormResult> {
+  return hearthNext.donateAction({ returnPath: "/donate/thank-you" })(prev, formData);
+}
+
+/**
+ * Registers for an event with on-site registration (sites with Tickets). Free tickets are confirmed straight away;
+ * paid ones redirect to the payment page, which brings the buyer back to /registered.
+ */
+export async function register(slug: string, prev: FormResult | null, formData: FormData): Promise<FormResult> {
+  return hearthNext.registerAction(slug, { returnPath: "/registered" })(prev, formData);
+}

package/template/src/app/api/preview/exit/route.ts

@@ -0,0 +1,4 @@
+import { hearthNext } from "@/lib/hearth";
+
+/** Ends a draft preview and returns to the published page (?path=/about). */
+export const GET = hearthNext.exitPreviewHandler();

package/template/src/app/api/preview/route.ts

@@ -0,0 +1,8 @@
+import { hearthNext } from "@/lib/hearth";
+
+/**
+ * Hearth's "Preview on the website" button opens this with a short-lived token. It checks the token with Hearth,
+ * turns on draft mode and opens the page, so editors see saved drafts until they exit or the preview ends.
+ * Hearth uses https://<domain>/api/preview unless the site has another preview address in Settings.
+ */
+export const GET = hearthNext.previewHandler();

package/template/src/app/api/revalidate/route.ts

@@ -0,0 +1,8 @@
+import { hearthNext } from "@/lib/hearth";
+
+/**
+ * Hearth calls this when anything on the site is published, so changes show up within seconds.
+ * Set the site's webhook URL in Hearth to https://<domain>/api/revalidate and copy the signing
+ * secret into HEARTH_WEBHOOK_SECRET. Unsigned or wrongly signed requests are rejected.
+ */
+export const POST = hearthNext.revalidateHandler();

package/template/src/app/donate/page.tsx

@@ -0,0 +1,27 @@
+import type { Metadata } from "next";
+import { notFound } from "next/navigation";
+import { DonateForm } from "@/components/DonateForm";
+import { Section } from "@/components/ui";
+import { hearthNext } from "@/lib/hearth";
+import { hasFeature } from "@/lib/site";
+
+export const metadata: Metadata = { title: "Donate", alternates: { canonical: "/donate" } };
+
+/**
+ * A general donation page (sites with Giving). Ask staff to reserve "donate" on the site's Plan card in Hearth so
+ * no page takes this address. For a page built in Hearth instead, use the Donation form block there.
+ */
+export default async function DonatePage() {
+  const site = await hearthNext.getSite();
+  if (!hasFeature(site, "giving")) notFound();
+  const giving = site.settings.giving;
+  return (
+    <Section>
+      <div className="max-w-2xl">
+        <h1 className="mb-4 text-[clamp(32px,4vw,48px)] font-bold tracking-tight">Donate</h1>
+        <p className="mb-10 text-lg opacity-85">Your gift supports {giving.legalName || site.name}.</p>
+        <DonateForm presetsCents={giving.presetsCents} minCents={giving.minCents} maxCents={giving.maxCents} />
+      </div>
+    </Section>
+  );
+}

package/template/src/app/donate/thank-you/page.tsx

@@ -0,0 +1,22 @@
+import type { Metadata } from "next";
+import Link from "next/link";
+import { Section } from "@/components/ui";
+
+export const metadata: Metadata = { title: "Thank you", robots: { index: false, follow: false } };
+
+/** Where the payment page sends donors back. The receipt is emailed once the payment completes. */
+export default function ThankYouPage() {
+  return (
+    <Section>
+      <div className="max-w-2xl">
+        <h1 className="mb-4 text-[clamp(32px,4vw,48px)] font-bold tracking-tight">Thank you</h1>
+        <p className="text-lg opacity-85">Your gift makes a difference. If you gave your email, a receipt is on its way.</p>
+        <p className="mt-8">
+          <Link href="/" className="font-semibold underline underline-offset-4">
+            Back to the homepage
+          </Link>
+        </p>
+      </div>
+    </Section>
+  );
+}

package/template/src/app/events/[slug]/page.tsx

@@ -0,0 +1,25 @@
+import { metadataFromMeta } from "@the-smithy/hearth/next";
+import { notFound, permanentRedirect } from "next/navigation";
+import { EventView } from "@/components/EventView";
+import { hearthNext } from "@/lib/hearth";
+import { hasFeature } from "@/lib/site";
+
+type Props = { params: Promise<{ slug: string }> };
+
+async function load(slug: string) {
+  const site = await hearthNext.getSite();
+  return hasFeature(site, "events") ? hearthNext.getEvent(slug) : null;
+}
+
+export async function generateMetadata({ params }: Props) {
+  const event = await load((await params).slug);
+  return event ? metadataFromMeta(event.meta) : {};
+}
+
+/** Events without a type live here. Events in a collection (e.g. Talks) live at their collection's address. */
+export default async function EventPage({ params }: Props) {
+  const event = await load((await params).slug);
+  if (!event) notFound();
+  if (event.path !== `/events/${event.slug}`) permanentRedirect(event.path);
+  return <EventView event={event} />;
+}

package/template/src/app/events/page.tsx

@@ -0,0 +1,21 @@
+import type { Metadata } from "next";
+import { notFound } from "next/navigation";
+import { EventList } from "@/components/blocks/events";
+import { Section } from "@/components/ui";
+import { hearthNext } from "@/lib/hearth";
+import { hasFeature } from "@/lib/site";
+
+export const metadata: Metadata = { title: "Events", alternates: { canonical: "/events" } };
+
+/** Upcoming events (only on sites with the Events feature in Hearth). */
+export default async function EventsPage() {
+  const site = await hearthNext.getSite();
+  if (!hasFeature(site, "events")) notFound();
+  const events = await hearthNext.getEvents({ when: "upcoming" });
+  return (
+    <Section>
+      <h1 className="mb-10 text-[clamp(32px,4vw,48px)] font-bold tracking-tight">Events</h1>
+      <EventList events={events} />
+    </Section>
+  );
+}