ferst-core 0.8.1 → 0.8.2

package/content/cookies.ts

@@ -150,7 +150,11 @@ function otherMapUse(provider: string): CookieUse {
 export interface CookieScanInput {
   /** Every block on the site's pages. Container children (`section` / `grid` / `stack`)
    *  are walked, so an embed nested in a grid counts. */
-  blocks: Iterable<BlockLike>;
+  blocks?: Iterable<BlockLike>;
+  /** @deprecated Block types alone, as before 0.8.1: judged by type, not by source (any
+   *  video block counts as YouTube and Vimeo). Kept so a site's own older policy page
+   *  still builds; pass `blocks`. */
+  blockTypes?: Iterable<string>;
   /** True when the site has a Google Calendar configured (dedicated calendar page). */
   calendarConfigured?: boolean;
 }
@@ -171,9 +175,25 @@ function allBlocks(blocks: Iterable<BlockLike>, acc: BlockLike[] = []): BlockLik
   return acc;
 }
 
+/** How a provider was detected before 0.8.1, from block types alone. */
+const BY_TYPE: Record<string, string[]> = {
+  'google-maps': ['locations', 'mapEmbed'],
+  'google-calendar': ['calendar'],
+  youtube: ['video'],
+  vimeo: ['video'],
+};
+
 /** Report the cookie uses actually active on a site, grouped by category. */
 export function scanCookieUses(input: CookieScanInput): CookiePolicyModel {
-  const blocks = allBlocks(input.blocks);
+  const necessary = NECESSARY.map((u) => ({ ...u }));
+  if (!input.blocks && input.blockTypes) {
+    const types = new Set(input.blockTypes);
+    const additional = ADDITIONAL.filter(
+      (u) => (BY_TYPE[u.id] ?? []).some((t) => types.has(t)) || (u.calendar === true && !!input.calendarConfigured),
+    ).map(({ loads, calendar, ...use }) => use);
+    return { necessary, additional };
+  }
+  const blocks = allBlocks(input.blocks ?? []);
   const additional: CookieUse[] = ADDITIONAL.filter(
     (u) => (u.loads ? blocks.some(u.loads) : false) || (u.calendar === true && !!input.calendarConfigured),
   ).map(({ loads, calendar, ...use }) => use); // drop detection fields from the view model
@@ -181,7 +201,7 @@ export function scanCookieUses(input: CookieScanInput): CookiePolicyModel {
   const otherMaps = new Set(blocks.map(mapProviderOf).filter((p): p is string => p !== undefined && !isGoogleMaps(p)));
   const afterMaps = additional.findIndex((u) => u.id !== 'google-maps');
   additional.splice(afterMaps === -1 ? additional.length : afterMaps, 0, ...[...otherMaps].map(otherMapUse));
-  return { necessary: NECESSARY.map((u) => ({ ...u })), additional };
+  return { necessary, additional };
 }
 
 /** Every block `type` used in a list of blocks, walking container children

package/lib/pages.ts

@@ -29,12 +29,21 @@ export async function getPageEntries() {
   return all.filter((entry) => !entry.data.draft);
 }
 
+/** The reserved entry a site may design as its own "page not found" page. */
+export const NOT_FOUND_ID = '404';
+
+/** The site's own "page not found" page, if it has designed one (a `404` entry). The
+ *  injected /404 route shows it at every missing address; it is never a page of its own. */
+export async function getNotFoundEntry() {
+  return (await getPageEntries()).find((entry) => entry.id === NOT_FOUND_ID);
+}
+
 /**
  * A drop-in `getStaticPaths` for a client's `[...slug].astro`: one route per
  * non-draft page, keyed by the file's slug, with the entry passed as a prop.
  */
 export async function getPageRoutes() {
-  const entries = await getPageEntries();
+  const entries = (await getPageEntries()).filter((entry) => entry.id !== NOT_FOUND_ID);
   return entries.map((entry) => ({
     params: { slug: entry.id },
     props: { entry },
@@ -58,7 +67,9 @@ export function pageRouteParams(id: string): { slug: string | undefined } {
  * AND can pick its home layout in the builder like any other page.
  */
 export async function getSiteRoutes() {
-  const entries = await getPageEntries();
+  // The `404` entry is the site's "page not found" page, shown by the /404 route at every
+  // missing address; it must not also be a page at /404/ (or listed in the sitemap).
+  const entries = (await getPageEntries()).filter((entry) => entry.id !== NOT_FOUND_ID);
   return entries.map((entry) => ({
     params: pageRouteParams(entry.id),
     props: { entry },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ferst-core",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "type": "module",
   "description": "Ferst Core — the shared, brand-agnostic client-site system: Astro components, layouts, content schemas, the layered config resolver, and a neutral styling architecture that every client overrides.",
   "license": "BUSL-1.1",

package/routes/404.astro

@@ -5,11 +5,16 @@
  * a `404.html` it serves the HOME PAGE with a 200 instead (a "soft 404"): search engines
  * would see the home page at every mistyped or retired address, and a broken link would
  * look fine to visitors and to the migration's redirect check. A site with its own
- * `src/pages/404.astro` keeps it (the integration skips this route then).
+ * `src/pages/404.astro` keeps it (the integration skips this route then). A site that has
+ * designed its "page not found" page as content (a `404` entry in `pages`) gets that page.
  */
 import Base from '../layouts/Base.astro';
 import BlockRenderer from '../components/BlockRenderer.astro';
 import { pageSchema } from '../content/blocks';
+import { getNotFoundEntry } from '../lib/pages';
+
+const own = await getNotFoundEntry();
+const ownPage = own ? pageSchema.parse(own.data) : null;
 
 const blog = import.meta.env.FERST_ROUTES_BLOG !== false;
 const page = pageSchema.parse({
@@ -31,6 +36,12 @@ const page = pageSchema.parse({
 });
 ---
 
-<Base title={page.title} description="This page isn't here." indexable={false}>
-  <BlockRenderer blocks={page.blocks} />
-</Base>
+{ownPage ? (
+  <Base title={ownPage.title} description={ownPage.description ?? "This page isn't here."} align={ownPage.align} indexable={false}>
+    <BlockRenderer blocks={ownPage.blocks} />
+  </Base>
+) : (
+  <Base title={page.title} description="This page isn't here." indexable={false}>
+    <BlockRenderer blocks={page.blocks} />
+  </Base>
+)}

package/routes/sitemap.xml.ts

@@ -3,7 +3,7 @@
 // and each tag page in use, and the calendar when it's set up. Drafts, hidden tags, later
 // listing pages (/posts/page/2…) and the cookie policy stay out.
 import type { APIRoute } from 'astro';
-import { getPageEntries, pageRouteParams } from '../lib/pages';
+import { getSiteRoutes } from '../lib/pages';
 import { canonicalUrl, sitemapXml } from '../lib/seo.mjs';
 
 export const prerender = true;
@@ -12,9 +12,9 @@ export const GET: APIRoute = async () => {
   const site = String(import.meta.env.FERST_SITE_URL || '');
   const entries: Array<{ loc: string; lastmod?: Date }> = [];
 
-  for (const page of await getPageEntries()) {
-    const { slug } = pageRouteParams(page.id);
-    entries.push({ loc: canonicalUrl(site, slug ? `/${slug}` : '/') });
+  // Exactly the pages the site routes (so never its "page not found" page).
+  for (const { params } of await getSiteRoutes()) {
+    entries.push({ loc: canonicalUrl(site, params.slug ? `/${params.slug}` : '/') });
   }
 
   if (import.meta.env.FERST_ROUTES_BLOG !== false) {