@trypattern/sdk 0.1.8 → 0.1.10

package/dist/server/jsonLd.js

@@ -0,0 +1,88 @@
+const TIME = /^([01]\d|2[0-3]):[0-5]\d$/;
+const CURRENCY = /^[A-Z]{3}$/;
+function present(fields) {
+    return Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined &&
+        value !== '' &&
+        !(Array.isArray(value) && value.length === 0)));
+}
+function postalAddress(address) {
+    if (address === undefined)
+        return undefined;
+    return {
+        '@type': 'PostalAddress',
+        ...present({
+            streetAddress: address.street,
+            addressLocality: address.locality,
+            addressRegion: address.region,
+            postalCode: address.postalCode,
+            addressCountry: address.country
+        })
+    };
+}
+function openingHours(hours) {
+    return hours?.map(({ days, opens, closes }) => {
+        if (!TIME.test(opens) || !TIME.test(closes)) {
+            throw new Error(`Opening hours are 24-hour HH:MM times, like 09:00 and 17:30 (got ${opens} to ${closes})`);
+        }
+        return {
+            '@type': 'OpeningHoursSpecification',
+            dayOfWeek: typeof days === 'string' ? days : [...days],
+            opens,
+            closes
+        };
+    });
+}
+export function localBusiness(facts) {
+    return {
+        '@context': 'https://schema.org',
+        '@type': facts.type ?? 'LocalBusiness',
+        ...present({
+            name: facts.name,
+            url: facts.url,
+            image: facts.image,
+            description: facts.description,
+            telephone: facts.telephone,
+            email: facts.email,
+            address: postalAddress(facts.address),
+            openingHoursSpecification: openingHours(facts.hours),
+            priceRange: facts.priceRange,
+            sameAs: facts.sameAs
+        })
+    };
+}
+export function product(facts) {
+    const { offer } = facts;
+    if (offer !== undefined) {
+        if (!Number.isFinite(offer.price) || offer.price < 0) {
+            throw new Error(`A price is a number of at least 0 (got ${offer.price})`);
+        }
+        if (!CURRENCY.test(offer.currency)) {
+            throw new Error(`A currency is a three-letter ISO 4217 code, like CAD or USD (got ${offer.currency})`);
+        }
+    }
+    return {
+        '@context': 'https://schema.org',
+        '@type': 'Product',
+        ...present({
+            name: facts.name,
+            url: facts.url,
+            image: facts.image,
+            description: facts.description,
+            sku: facts.sku,
+            brand: facts.brand === undefined
+                ? undefined
+                : { '@type': 'Brand', name: facts.brand },
+            offers: offer === undefined
+                ? undefined
+                : present({
+                    '@type': 'Offer',
+                    price: offer.price.toFixed(2),
+                    priceCurrency: offer.currency,
+                    availability: offer.availability === undefined
+                        ? undefined
+                        : `https://schema.org/${offer.availability}`,
+                    url: facts.url
+                })
+        })
+    };
+}

package/dist/server/keyset.d.ts

@@ -0,0 +1,13 @@
+import type { SQLiteColumn } from 'drizzle-orm/sqlite-core';
+import type { Context } from 'hono';
+import type { ServerEnv } from './env.ts';
+export declare const PAGE_PROBLEM = "limit must be 1 to 1000, after a cursor";
+export type Page = {
+    readonly limit: number;
+    readonly after: readonly [string, string] | undefined;
+};
+export declare function pageOf(c: Context<ServerEnv>): Page | undefined | 'invalid';
+export declare function afterCursor(createdAt: SQLiteColumn, id: SQLiteColumn, page: Page | undefined): import("drizzle-orm").SQL<unknown> | undefined;
+export declare function pageReply(c: Context<ServerEnv>, rows: readonly Readonly<Record<string, unknown>>[], page: Page | undefined): Response & import("hono").TypedResponse<readonly {
+    readonly [x: string]: import("hono/utils/types").JSONValue;
+}[], import("hono/utils/http-status").ContentfulStatusCode, "json">;

package/dist/server/keyset.js

@@ -0,0 +1,52 @@
+import { and, eq, gt, or } from 'drizzle-orm';
+import { z } from 'zod';
+import { NEXT_PAGE_HEADER } from "../patternAccess.js";
+const PAGE_LIMIT = 1000;
+export const PAGE_PROBLEM = 'limit must be 1 to 1000, after a cursor';
+const pageQuery = z.object({
+    limit: z.coerce.number().int().min(1).max(PAGE_LIMIT).optional(),
+    after: z.string().min(1).optional()
+});
+const cursor = z.tuple([z.string(), z.string()]);
+function cursorOf(row) {
+    return btoa(JSON.stringify([row['createdAt'], row['id']]))
+        .replaceAll('+', '-')
+        .replaceAll('/', '_')
+        .replaceAll('=', '');
+}
+function cursorParts(text) {
+    try {
+        const parsed = cursor.safeParse(JSON.parse(atob(text.replaceAll('-', '+').replaceAll('_', '/'))));
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function pageOf(c) {
+    const parsed = pageQuery.safeParse(c.req.query());
+    if (!parsed.success)
+        return 'invalid';
+    const { limit, after } = parsed.data;
+    if (limit === undefined)
+        return after === undefined ? undefined : 'invalid';
+    if (after === undefined)
+        return { limit, after: undefined };
+    const parts = cursorParts(after);
+    return parts === undefined ? 'invalid' : { limit, after: parts };
+}
+export function afterCursor(createdAt, id, page) {
+    if (page?.after === undefined)
+        return undefined;
+    const [at, lastId] = page.after;
+    return or(gt(createdAt, at), and(eq(createdAt, at), gt(id, lastId)));
+}
+export function pageReply(c, rows, page) {
+    if (page === undefined || rows.length <= page.limit)
+        return c.json(rows);
+    const shown = rows.slice(0, page.limit);
+    const last = shown.at(-1);
+    if (last !== undefined)
+        c.header(NEXT_PAGE_HEADER, cursorOf(last));
+    return c.json(shown);
+}

package/dist/server/media.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from 'hono';
+import type { ServerEnv } from './env.ts';
+export declare function uploadMedia(c: Context<ServerEnv>): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 401, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 403, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 503, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 413, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 415, "json">) | (Response & import("hono").TypedResponse<{}, 201, "json">)>;
+export declare function serveMedia(c: Context<ServerEnv>): Promise<Response>;

package/dist/server/media.js

@@ -0,0 +1,135 @@
+import { drizzle } from 'drizzle-orm/d1';
+import { MEDIA_LIMIT_BYTES, media, mediaPath } from "../media.js";
+import { isHeic, readImageHeader } from "./imageHeader.js";
+import { sqlTable } from "./tables.js";
+const FORM_OVERHEAD_BYTES = 64 * 1024;
+const ALT_LIMIT = 500;
+const KEY = /^images\/[0-9a-f]{16}\.(?:jpg|png|webp|gif|avif)$/;
+const IMMUTABLE = 'public, max-age=31536000, immutable';
+const PLACEHOLDER = {
+    width: 24,
+    quality: 50,
+    format: 'jpeg',
+    fit: 'scale-down'
+};
+const PLACEHOLDER_LIMIT_BYTES = 4096;
+const NO_BUCKET = 'This app has no MEDIA bucket. Add "r2_buckets": [{ "binding": "MEDIA", "bucket_name": "media" }] to wrangler.jsonc; publishing creates the real one.';
+const NO_ALT = 'Describe this photo for someone who can’t see it: alt is required.';
+const TOO_LARGE = 'Photos can be up to 10 MB.';
+const HEIC = 'This is an iPhone HEIC photo, which browsers can’t show. Send it as a JPEG instead.';
+const UNKNOWN_TYPE = 'Photos must be JPEG, PNG, WebP, GIF or AVIF.';
+const target = sqlTable(media);
+function hex(bytes) {
+    return [...new Uint8Array(bytes)]
+        .map((byte) => byte.toString(16).padStart(2, '0'))
+        .join('');
+}
+function base64(bytes) {
+    let text = '';
+    const view = new Uint8Array(bytes);
+    for (let index = 0; index < view.length; index += 0x8000) {
+        text += String.fromCharCode(...view.subarray(index, index + 0x8000));
+    }
+    return btoa(text);
+}
+async function placeholderOf(c, key) {
+    if (import.meta.env.DEV)
+        return null;
+    const init = { method: 'GET', cf: { image: PLACEHOLDER } };
+    try {
+        const response = await fetch(new URL(mediaPath(key), c.req.url).href, init);
+        const type = response.headers.get('content-type') ?? '';
+        const length = Number(response.headers.get('content-length') ?? 0);
+        if (!response.ok ||
+            !type.startsWith('image/jpeg') ||
+            length > PLACEHOLDER_LIMIT_BYTES) {
+            await response.body?.cancel();
+            return null;
+        }
+        const bytes = await response.arrayBuffer();
+        return bytes.byteLength > PLACEHOLDER_LIMIT_BYTES
+            ? null
+            : `data:image/jpeg;base64,${base64(bytes)}`;
+    }
+    catch {
+        return null;
+    }
+}
+export async function uploadMedia(c) {
+    const viewer = c.get('viewer');
+    if (viewer === null)
+        return c.json({ error: 'Signed out' }, 401);
+    if (!viewer.isAdmin)
+        return c.json({ error: 'forbidden' }, 403);
+    const bucket = c.env.MEDIA;
+    if (bucket === undefined)
+        return c.json({ error: NO_BUCKET }, 503);
+    const declared = Number(c.req.header('content-length') ?? 0);
+    if (declared > MEDIA_LIMIT_BYTES + FORM_OVERHEAD_BYTES) {
+        return c.json({ error: TOO_LARGE }, 413);
+    }
+    const form = await c.req.formData().catch(() => undefined);
+    const file = form?.get('file');
+    const alt = form?.get('alt');
+    if (!(file instanceof File)) {
+        return c.json({ error: 'Send the photo as the form field "file".' }, 400);
+    }
+    if (typeof alt !== 'string' || alt.trim() === '') {
+        return c.json({ error: NO_ALT }, 400);
+    }
+    if (alt.trim().length > ALT_LIMIT) {
+        return c.json({ error: `Keep alt to ${ALT_LIMIT} characters.` }, 400);
+    }
+    if (file.size > MEDIA_LIMIT_BYTES)
+        return c.json({ error: TOO_LARGE }, 413);
+    const buffer = await file.arrayBuffer();
+    const bytes = new Uint8Array(buffer);
+    if (isHeic(bytes))
+        return c.json({ error: HEIC }, 415);
+    const header = readImageHeader(bytes);
+    if (header === undefined)
+        return c.json({ error: UNKNOWN_TYPE }, 415);
+    const digest = await crypto.subtle.digest('SHA-256', buffer);
+    const key = `images/${hex(digest).slice(0, 16)}.${header.extension}`;
+    await bucket.put(key, buffer, {
+        httpMetadata: { contentType: header.type, cacheControl: IMMUTABLE }
+    });
+    const row = await drizzle(c.env.DB)
+        .insert(target)
+        .values({
+        id: crypto.randomUUID(),
+        key,
+        width: header.width,
+        height: header.height,
+        placeholder: await placeholderOf(c, key),
+        alt: alt.trim(),
+        type: header.type,
+        bytes: bytes.byteLength
+    })
+        .returning()
+        .get();
+    return c.json(row, 201);
+}
+function unquoted(etag) {
+    return etag.replace(/^W\//, '').replaceAll('"', '').trim();
+}
+export async function serveMedia(c) {
+    const key = decodeURIComponent(c.req.path.slice('/media/'.length));
+    const bucket = c.env.MEDIA;
+    if (!KEY.test(key) || bucket === undefined) {
+        return c.text('No such photo', 404);
+    }
+    const seen = c.req.header('if-none-match');
+    const object = await bucket.get(key, seen === undefined ? {} : { onlyIf: { etagDoesNotMatch: unquoted(seen) } });
+    if (object === null)
+        return c.text('No such photo', 404);
+    const headers = new Headers({
+        'cache-control': IMMUTABLE,
+        'content-type': object.httpMetadata?.contentType ?? 'application/octet-stream',
+        etag: object.httpEtag,
+        'x-content-type-options': 'nosniff'
+    });
+    if (!('body' in object))
+        return new Response(null, { status: 304, headers });
+    return new Response(object.body, { headers });
+}

package/dist/server/pages.d.ts

@@ -0,0 +1,72 @@
+import type { Context } from 'hono';
+import type { MediaImage } from '../media.ts';
+import type { Row, Tables } from '../table.ts';
+import type { ServerEnv } from './env.ts';
+import type { JsonLd } from './jsonLd.ts';
+type ReadableName<Group extends Tables> = {
+    [Key in keyof Group & string]: Group[Key]['access']['read'] extends 'anyone' ? Key : never;
+}[keyof Group & string];
+type Answer<Value> = Value | Promise<Value>;
+export type PageParams = Readonly<Record<string, string>>;
+export type PageRequest<Group extends Tables> = {
+    url: URL;
+    params: PageParams;
+    rows: <Name extends ReadableName<Group>>(table: Name) => Promise<readonly Row<Group[Name]>[]>;
+    row: <Name extends ReadableName<Group>>(table: Name, id: string) => Promise<Row<Group[Name]> | undefined>;
+    photoUrl: (image: MediaImage) => string;
+};
+export type PageHero = {
+    image: MediaImage;
+    sizes: string;
+    aspect?: number;
+};
+export type PageHead<Group extends Tables> = {
+    title: string;
+    description?: string;
+    image?: MediaImage | null;
+    hero?: PageHero | null;
+    jsonLd?: JsonLd | readonly JsonLd[];
+    data?: {
+        [Name in ReadableName<Group>]?: readonly Row<Group[Name]>[];
+    };
+};
+type HeadOf<Group extends Tables> = (request: PageRequest<Group>) => Answer<PageHead<Group> | null>;
+export type PageDefinition<Group extends Tables> = HeadOf<Group> | {
+    head: HeadOf<Group>;
+    paths: (request: PageRequest<Group>) => Answer<readonly PageParams[]>;
+};
+type AnyHead = {
+    title: string;
+    description?: string;
+    image?: MediaImage | null;
+    hero?: PageHero | null;
+    jsonLd?: JsonLd | readonly JsonLd[];
+    data?: Readonly<Record<string, readonly unknown[] | undefined>>;
+};
+type AnyRequest = {
+    url: URL;
+    params: PageParams;
+    rows: (table: string) => Promise<readonly unknown[]>;
+    row: (table: string, id: string) => Promise<unknown>;
+    photoUrl: (image: MediaImage) => string;
+};
+type PageRoute = {
+    pattern: string;
+    segments: readonly string[];
+    head: (request: AnyRequest) => Answer<AnyHead | null>;
+    paths?: (request: AnyRequest) => Answer<readonly PageParams[]>;
+};
+export type Pages = {
+    readonly tables: Tables;
+    readonly routes: readonly PageRoute[];
+};
+export declare function definePages<Group extends Tables>(tables: Group, pages: Readonly<Record<string, PageDefinition<Group>>>): Pages;
+export declare function matchPage(pages: Pages, path: string): {
+    route: PageRoute;
+    params: PageParams;
+} | undefined;
+export declare function wantsHtml(c: Context<ServerEnv>): boolean;
+export declare function renderPage(c: Context<ServerEnv>, pages: Pages, route: PageRoute, params: PageParams): Promise<Response>;
+export declare function sitemap(c: Context<ServerEnv>, pages: Pages): Promise<Response>;
+export declare function robots(c: Context<ServerEnv>): Response;
+export {};

package/dist/server/pages.js

@@ -0,0 +1,301 @@
+import { imageSources, mediaPath, transformsOn } from "../media.js";
+import { readTitle } from "./settings.js";
+import { readRow, readRows } from "./tables.js";
+const SEGMENT = /^(:[A-Za-z_]\w*|[\w.~-]+)$/;
+const OG_WIDTH = 1200;
+const OG_HEIGHT = 630;
+const SITEMAP_LIMIT = 1000;
+const DATA_ID = 'pattern-data';
+function segmentsOf(pattern) {
+    if (!pattern.startsWith('/')) {
+        throw new Error(`A page path starts with /: "${pattern}"`);
+    }
+    const segments = pattern.split('/').filter((segment) => segment !== '');
+    const wrong = segments.find((segment) => !SEGMENT.test(segment));
+    if (wrong !== undefined) {
+        throw new Error(`"${pattern}" is not a page path: use words and :params, like /items/:itemId`);
+    }
+    return segments;
+}
+export function definePages(tables, pages) {
+    return {
+        tables,
+        routes: Object.entries(pages).map(([pattern, definition]) => {
+            const page = definition;
+            return {
+                pattern,
+                segments: segmentsOf(pattern),
+                ...(typeof page === 'function' ? { head: page } : page)
+            };
+        })
+    };
+}
+export function matchPage(pages, path) {
+    const parts = path
+        .split('/')
+        .filter((part) => part !== '')
+        .map((part) => {
+        try {
+            return decodeURIComponent(part);
+        }
+        catch {
+            return part;
+        }
+    });
+    for (const route of pages.routes) {
+        if (route.segments.length !== parts.length)
+            continue;
+        const params = {};
+        const matches = route.segments.every((segment, index) => {
+            const part = parts[index] ?? '';
+            if (segment.startsWith(':')) {
+                params[segment.slice(1)] = part;
+                return true;
+            }
+            return segment === part;
+        });
+        if (matches)
+            return { route, params };
+    }
+    return undefined;
+}
+function readableTable(pages, name) {
+    const table = pages.tables[name];
+    if (table === undefined)
+        throw new Error(`There is no table "${name}"`);
+    if (table.access.read !== 'anyone') {
+        throw new Error(`Pages are public, so they read only tables anyone may read; "${name}" has read: '${table.access.read}'`);
+    }
+    return table;
+}
+function requestFor(c, pages, params) {
+    const url = new URL(c.req.url);
+    const read = new Map();
+    return {
+        url,
+        params,
+        rows: (name) => {
+            const table = readableTable(pages, name);
+            const found = read.get(name) ?? readRows(c.env.DB, table);
+            read.set(name, found);
+            return found;
+        },
+        row: (name, id) => readRow(c.env.DB, readableTable(pages, name), id),
+        photoUrl: (image) => `${url.origin}${mediaPath(image.key)}`
+    };
+}
+function escapeHtml(text) {
+    return text
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
+}
+function scriptJson(value) {
+    return JSON.stringify(value)
+        .replaceAll('<', '\\u003c')
+        .replaceAll('
', '\\u2028')
+        .replaceAll('
', '\\u2029');
+}
+function meta(attribute, key, content) {
+    return `<meta ${attribute}="${key}" content="${escapeHtml(content)}">`;
+}
+function openGraphImage(url, image) {
+    if (!transformsOn(url.hostname)) {
+        return {
+            src: `${url.origin}${mediaPath(image.key)}`,
+            width: image.width,
+            height: image.height
+        };
+    }
+    const options = `width=${OG_WIDTH},height=${OG_HEIGHT},quality=82,format=jpeg,fit=cover`;
+    return {
+        src: `${url.origin}/cdn-cgi/image/${options}${mediaPath(image.key)}`,
+        width: OG_WIDTH,
+        height: OG_HEIGHT
+    };
+}
+function heroPreload(url, hero) {
+    const sources = imageSources(hero.image, {
+        aspect: hero.aspect,
+        transforms: transformsOn(url.hostname)
+    });
+    const attributes = [
+        'rel="preload"',
+        'as="image"',
+        'fetchpriority="high"',
+        `href="${escapeHtml(sources.src)}"`,
+        ...(sources.srcSet === undefined
+            ? []
+            : [
+                `imagesrcset="${escapeHtml(sources.srcSet)}"`,
+                `imagesizes="${escapeHtml(hero.sizes)}"`
+            ])
+    ];
+    return `<link ${attributes.join(' ')}>`;
+}
+function dataOf(pages, head) {
+    return Object.fromEntries(Object.entries(head.data ?? {}).flatMap(([name, rows]) => {
+        if (rows === undefined)
+            return [];
+        readableTable(pages, name);
+        return [[name, rows]];
+    }));
+}
+function headTags(pages, url, siteName, head) {
+    const canonical = `${url.origin}${url.pathname}`;
+    const image = head.image ?? head.hero?.image;
+    const og = image === undefined || image === null
+        ? undefined
+        : openGraphImage(url, image);
+    const jsonLd = head.jsonLd === undefined
+        ? []
+        : Array.isArray(head.jsonLd)
+            ? head.jsonLd
+            : [head.jsonLd];
+    return [
+        ...(head.description === undefined
+            ? []
+            : [
+                meta('name', 'description', head.description),
+                meta('property', 'og:description', head.description)
+            ]),
+        `<link rel="canonical" href="${escapeHtml(canonical)}">`,
+        meta('property', 'og:type', 'website'),
+        meta('property', 'og:title', head.title),
+        meta('property', 'og:url', canonical),
+        ...(siteName === '' ? [] : [meta('property', 'og:site_name', siteName)]),
+        ...(og === undefined || image === undefined || image === null
+            ? [meta('name', 'twitter:card', 'summary')]
+            : [
+                meta('property', 'og:image', og.src),
+                meta('property', 'og:image:width', String(og.width)),
+                meta('property', 'og:image:height', String(og.height)),
+                meta('property', 'og:image:alt', image.alt),
+                meta('name', 'twitter:card', 'summary_large_image')
+            ]),
+        ...(head.hero === undefined || head.hero === null
+            ? []
+            : [heroPreload(url, head.hero)]),
+        ...jsonLd.map((item) => `<script type="application/ld+json">${scriptJson(item)}</script>`),
+        `<script type="application/json" id="${DATA_ID}">${scriptJson(dataOf(pages, head))}</script>`
+    ].join('\n    ');
+}
+const TITLE = /<title>[\s\S]*?<\/title>/;
+const DESCRIPTION = /\s*<meta\s+name="description"[^>]*>/gi;
+function rewrite(shell, title, tags) {
+    const titleTag = `<title>${escapeHtml(title)}</title>`;
+    const titled = TITLE.test(shell)
+        ? shell.replace(TITLE, titleTag)
+        : shell.replace('</head>', `  ${titleTag}\n  </head>`);
+    return titled
+        .replace(DESCRIPTION, '')
+        .replace('</head>', `  ${tags}\n  </head>`);
+}
+async function shellOf(c) {
+    const assets = c.env.ASSETS;
+    if (assets === undefined)
+        return undefined;
+    const response = await assets.fetch(new URL('/', c.req.url).href);
+    return response.ok ? response.text() : undefined;
+}
+const HTML = { 'content-type': 'text/html; charset=utf-8' };
+export function wantsHtml(c) {
+    return (c.req.method === 'GET' &&
+        (c.req.header('sec-fetch-dest') === 'document' ||
+            (c.req.header('accept') ?? '').includes('text/html')));
+}
+export async function renderPage(c, pages, route, params) {
+    const shell = await shellOf(c);
+    if (shell === undefined) {
+        return c.text('Pages need the built index.html: add "binding": "ASSETS" under "assets" in wrangler.jsonc', 500);
+    }
+    const request = requestFor(c, pages, params);
+    let head;
+    let tags = '';
+    try {
+        head = await route.head(request);
+        if (head !== null) {
+            tags = headTags(pages, request.url, await readTitle(c.env.DB), head);
+        }
+    }
+    catch (error) {
+        if (import.meta.env.DEV)
+            throw error;
+        console.error(`Page ${route.pattern} failed:`, error);
+        return new Response(shell, { headers: HTML });
+    }
+    if (head === null) {
+        const missing = rewrite(shell, 'Not found', `${meta('name', 'robots', 'noindex')}\n    <script type="application/json" id="${DATA_ID}">{}</script>`);
+        return new Response(missing, { status: 404, headers: HTML });
+    }
+    return new Response(rewrite(shell, head.title, tags), { headers: HTML });
+}
+function fill(route, params) {
+    const parts = route.segments.map((segment) => segment.startsWith(':') ? params[segment.slice(1)] : segment);
+    if (parts.some((part) => part === undefined || part === ''))
+        return undefined;
+    return `/${parts.map((part) => encodeURIComponent(part ?? '')).join('/')}`;
+}
+async function sitemapEntries(c, pages) {
+    const entries = [];
+    for (const route of pages.routes) {
+        const isStatic = route.segments.every((segment) => !segment.startsWith(':'));
+        const listed = isStatic
+            ? [{}]
+            : route.paths === undefined
+                ? []
+                : await route.paths(requestFor(c, pages, {}));
+        for (const params of listed) {
+            const path = fill(route, params);
+            if (path !== undefined)
+                entries.push({ path, route, params });
+        }
+    }
+    return entries.slice(0, SITEMAP_LIMIT);
+}
+export async function sitemap(c, pages) {
+    const origin = new URL(c.req.url).origin;
+    const urls = [];
+    for (const { path, route, params } of await sitemapEntries(c, pages)) {
+        const request = requestFor(c, pages, params);
+        const head = await (async () => route.head(request))().catch(() => null);
+        if (head === null)
+            continue;
+        const image = head.image ?? head.hero?.image;
+        urls.push([
+            '  <url>',
+            `    <loc>${escapeHtml(`${origin}${path}`)}</loc>`,
+            ...(image === undefined || image === null
+                ? []
+                : [
+                    '    <image:image>',
+                    `      <image:loc>${escapeHtml(request.photoUrl(image))}</image:loc>`,
+                    `      <image:caption>${escapeHtml(image.alt)}</image:caption>`,
+                    '    </image:image>'
+                ]),
+            '  </url>'
+        ].join('\n'));
+    }
+    const xml = [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">',
+        ...urls,
+        '</urlset>',
+        ''
+    ].join('\n');
+    return new Response(xml, {
+        headers: { 'content-type': 'application/xml; charset=utf-8' }
+    });
+}
+export function robots(c) {
+    const origin = new URL(c.req.url).origin;
+    return new Response([
+        'User-agent: *',
+        'Allow: /',
+        'Disallow: /api/',
+        `Sitemap: ${origin}/sitemap.xml`,
+        ''
+    ].join('\n'), { headers: { 'content-type': 'text/plain; charset=utf-8' } });
+}

package/dist/server/patternKeys.d.ts

@@ -0,0 +1 @@
+export declare const PATTERN_KEYS: Readonly<Record<string, string>>;