@geekity/cms 0.3.0

package/dist/web/pagination.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Where one listing page sits in the sequence.
+ *
+ * `pageNumber` is zero-based, as it is in Eleventy, so a layout ported from an
+ * Eleventy build does the same arithmetic. `href` holds the URLs a pager needs;
+ * `next` and `previous` are `null` at the ends rather than absent, which is
+ * what Eleventy does and what `{% if pagination.href.next %}` expects.
+ */
+export interface Pagination {
+    /** Zero-based index of this page. */
+    pageNumber: number;
+    /** How many pages the listing has. At least 1, even when it is empty. */
+    totalPages: number;
+    /** How many documents the whole listing holds. */
+    total: number;
+    /** How many documents fit on a page. */
+    size: number;
+    /** Where the pager links. */
+    href: {
+        first: string;
+        last: string;
+        next: string | null;
+        previous: string | null;
+    };
+    /** Every page's URL, in order, so a template can render a numbered pager. */
+    pages: string[];
+}
+/** What {@link paginate} needs to place a page. */
+export interface PaginateOptions {
+    /** How many documents the listing holds in total. */
+    total: number;
+    /** How many fit on a page. Values below 1 are treated as 1. */
+    size: number;
+    /** Zero-based index of the page being rendered. */
+    pageNumber: number;
+    /** The URL of a page, by zero-based index. */
+    hrefForPage: (index: number) => string;
+}
+/** How many documents to skip to reach a page. */
+export declare function offsetForPage(pageNumber: number, size: number): number;
+/**
+ * The page count and the pager URLs for a listing.
+ *
+ * An empty listing still has one page, so the home page of a site with no
+ * posts renders normally instead of 404ing.
+ */
+export declare function paginate(options: PaginateOptions): Pagination;
+//# sourceMappingURL=pagination.d.ts.map

package/dist/web/pagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../src/web/pagination.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB,qCAAqC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,UAAU,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,6BAA6B;IAC7B,IAAI,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QACpB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;KACzB,CAAC;IACF,6EAA6E;IAC7E,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,mDAAmD;AACnD,MAAM,WAAW,eAAe;IAC9B,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,8CAA8C;IAC9C,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;CACxC;AAED,kDAAkD;AAClD,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,UAAU,CAmB7D"}

package/dist/web/pagination.js

@@ -0,0 +1,30 @@
+/** How many documents to skip to reach a page. */
+export function offsetForPage(pageNumber, size) {
+    return pageNumber * Math.max(1, size);
+}
+/**
+ * The page count and the pager URLs for a listing.
+ *
+ * An empty listing still has one page, so the home page of a site with no
+ * posts renders normally instead of 404ing.
+ */
+export function paginate(options) {
+    const size = Math.max(1, options.size);
+    const totalPages = Math.max(1, Math.ceil(options.total / size));
+    const pageNumber = options.pageNumber;
+    const pages = Array.from({ length: totalPages }, (_, index) => options.hrefForPage(index));
+    return {
+        pageNumber,
+        totalPages,
+        total: options.total,
+        size,
+        href: {
+            first: options.hrefForPage(0),
+            last: options.hrefForPage(totalPages - 1),
+            next: pageNumber + 1 < totalPages ? options.hrefForPage(pageNumber + 1) : null,
+            previous: pageNumber > 0 ? options.hrefForPage(pageNumber - 1) : null,
+        },
+        pages,
+    };
+}
+//# sourceMappingURL=pagination.js.map

package/dist/web/pagination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.js","sourceRoot":"","sources":["../../src/web/pagination.ts"],"names":[],"mappings":"AAwCA,kDAAkD;AAClD,MAAM,UAAU,aAAa,CAAC,UAAkB,EAAE,IAAY;IAC5D,OAAO,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;AACxC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,OAAwB;IAC/C,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC;IAChE,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IACtC,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;IAE3F,OAAO;QACL,UAAU;QACV,UAAU;QACV,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,IAAI;QACJ,IAAI,EAAE;YACJ,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;YAC7B,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,UAAU,GAAG,CAAC,CAAC;YACzC,IAAI,EAAE,UAAU,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI;YAC9E,QAAQ,EAAE,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI;SACtE;QACD,KAAK;KACN,CAAC;AACJ,CAAC"}

package/dist/web/render.d.ts

@@ -0,0 +1,72 @@
+import type { Environment } from 'nunjucks';
+import type { ResolvedConfig } from '../config.ts';
+import type { Document } from '../content/document.ts';
+import type { SiteData, SiteSettingsSource } from './context.ts';
+import type { Pagination } from './pagination.ts';
+/** Templates the default theme ships and the public routes ask for by name. */
+export declare const TEMPLATES: {
+    readonly home: 'layouts/home.njk';
+    readonly post: 'layouts/post.njk';
+    readonly page: 'layouts/page.njk';
+    readonly tag: 'layouts/tag.njk';
+    readonly notFound: 'layouts/404.njk';
+};
+/** A listing of documents, ready to render. */
+export interface Listing {
+    /** Heading for the page, and the basis of its `<title>`. */
+    title: string;
+    /** The listing's own URL, for `page.url`. */
+    url: string;
+    /** The documents on this page of the listing, newest first. */
+    documents: Document[];
+    /** Where this page sits in the sequence. */
+    pagination: Pagination;
+    /** The tag, on a tag archive. Absent on the home page. */
+    tag?: string | undefined;
+    /** Which template to use. Defaults to the home layout. */
+    template?: string | undefined;
+}
+/**
+ * The HTML side of the public site: everything that turns a document or a
+ * listing into a page of the theme.
+ *
+ * It is deliberately separate from the routes. Content negotiation picks a
+ * representation and then asks the renderer for the HTML one; feeds ask for
+ * nothing here at all. Nothing in this interface touches a request.
+ */
+export interface Renderer {
+    /** Site-wide data, re-read when `content/_data/site.json` changes. */
+    site(): SiteData;
+    /** How many documents a listing page holds, per the site data. */
+    pageSize(): number;
+    /** One document through its type's layout. */
+    renderDocument(document: Document): string;
+    /** A listing through the home or tag layout. */
+    renderListing(listing: Listing): string;
+    /** The 404 page, for a path that resolved to nothing. */
+    renderNotFound(url: string): string;
+    /** Any template by name, with the site data already in the context. */
+    render(template: string, context?: Record<string, unknown>): string;
+    /** The Nunjucks environment, for a site that wants to add its own filters. */
+    readonly environment: Environment;
+}
+/** How to build a {@link Renderer}. */
+export interface CreateRendererOptions {
+    /** Config after defaults, for the theme directory, base URL and content directory. */
+    config: ResolvedConfig;
+    /**
+     * The admin's stored settings, which win over `content/_data/site.json` for
+     * the values the settings screen manages. Absent for a renderer built
+     * without an admin store, which then reads the file alone.
+     */
+    settings?: SiteSettingsSource | undefined;
+}
+/**
+ * Build the renderer for one site.
+ *
+ * Templates are cached unless the content watcher is on, which is the same
+ * switch as "this is a development server": with `watch: true` a template edit
+ * shows up on the next request, exactly as a content edit does.
+ */
+export declare function createRenderer(options: CreateRendererOptions): Renderer;
+//# sourceMappingURL=render.d.ts.map

package/dist/web/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/web/render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAGvD,OAAO,KAAK,EAAmB,QAAQ,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAGlD,+EAA+E;AAC/E,eAAO,MAAM,SAAS;aACpB,IAAI,EAAE,kBAAkB;aACxB,IAAI,EAAE,kBAAkB;aACxB,IAAI,EAAE,kBAAkB;aACxB,GAAG,EAAE,iBAAiB;aACtB,QAAQ,EAAE,iBAAiB;CACnB,CAAC;AAEX,+CAA+C;AAC/C,MAAM,WAAW,OAAO;IACtB,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAC;IACd,6CAA6C;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,+DAA+D;IAC/D,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,4CAA4C;IAC5C,UAAU,EAAE,UAAU,CAAC;IACvB,0DAA0D;IAC1D,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB,sEAAsE;IACtE,IAAI,IAAI,QAAQ,CAAC;IACjB,kEAAkE;IAClE,QAAQ,IAAI,MAAM,CAAC;IACnB,8CAA8C;IAC9C,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC3C,gDAAgD;IAChD,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC;IACxC,yDAAyD;IACzD,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IACpC,uEAAuE;IACvE,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC;IACpE,8EAA8E;IAC9E,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;CACnC;AAED,uCAAuC;AACvC,MAAM,WAAW,qBAAqB;IACpC,sFAAsF;IACtF,MAAM,EAAE,cAAc,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;CAC3C;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,QAAQ,CA8DvE"}

package/dist/web/render.js

@@ -0,0 +1,73 @@
+import { createSiteDataSource, documentContext, postsPerPage } from './context.js';
+import { activityStreamsId } from './documents.js';
+import { createTemplateEnvironment } from './templates.js';
+/** Templates the default theme ships and the public routes ask for by name. */
+export const TEMPLATES = {
+    home: 'layouts/home.njk',
+    post: 'layouts/post.njk',
+    page: 'layouts/page.njk',
+    tag: 'layouts/tag.njk',
+    notFound: 'layouts/404.njk',
+};
+/**
+ * Build the renderer for one site.
+ *
+ * Templates are cached unless the content watcher is on, which is the same
+ * switch as "this is a development server": with `watch: true` a template edit
+ * shows up on the next request, exactly as a content edit does.
+ */
+export function createRenderer(options) {
+    const { config } = options;
+    const environment = createTemplateEnvironment({
+        themeDir: config.themeDir,
+        baseUrl: config.baseUrl,
+        noCache: config.watch,
+    });
+    const siteData = createSiteDataSource(config, { settings: options.settings });
+    function render(template, context = {}) {
+        const site = siteData.read();
+        return environment.render(template, { site, ...context });
+    }
+    return {
+        environment,
+        site() {
+            return siteData.read();
+        },
+        pageSize() {
+            return postsPerPage(siteData.read());
+        },
+        renderDocument(document) {
+            const template = document.type === 'post' ? TEMPLATES.post : TEMPLATES.page;
+            // `activityStreams` is the object id the base layout advertises. It is
+            // added here rather than in `documentContext` because it needs the
+            // site's base URL, which a document on its own does not carry.
+            const objectId = activityStreamsId(document, config.baseUrl);
+            return render(template, {
+                ...documentContext(document),
+                ...(objectId === undefined ? {} : { activityStreams: objectId }),
+            });
+        },
+        renderListing(listing) {
+            const items = listing.documents.map(documentContext);
+            return render(listing.template ?? TEMPLATES.home, {
+                title: listing.title,
+                url: listing.url,
+                page: { url: listing.url },
+                // `posts` is the friendly name a theme loops over; `pagination.items`
+                // is the same array under the name Eleventy gives it.
+                posts: items,
+                pagination: { ...listing.pagination, items },
+                ...(listing.tag === undefined ? {} : { tag: listing.tag }),
+            });
+        },
+        renderNotFound(url) {
+            return render(TEMPLATES.notFound, {
+                title: 'Not found',
+                url,
+                page: { url },
+            });
+        },
+        render,
+    };
+}
+//# sourceMappingURL=render.js.map

package/dist/web/render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.js","sourceRoot":"","sources":["../../src/web/render.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACnF,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGnD,OAAO,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,+EAA+E;AAC/E,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,IAAI,EAAE,kBAAkB;IACxB,IAAI,EAAE,kBAAkB;IACxB,IAAI,EAAE,kBAAkB;IACxB,GAAG,EAAE,iBAAiB;IACtB,QAAQ,EAAE,iBAAiB;CACnB,CAAC;AAuDX;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,OAA8B;IAC3D,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IAC3B,MAAM,WAAW,GAAG,yBAAyB,CAAC;QAC5C,QAAQ,EAAE,MAAM,CAAC,QAAQ;QACzB,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,OAAO,EAAE,MAAM,CAAC,KAAK;KACtB,CAAC,CAAC;IACH,MAAM,QAAQ,GAAG,oBAAoB,CAAC,MAAM,EAAE,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAE9E,SAAS,MAAM,CAAC,QAAgB,EAAE,OAAO,GAA4B,EAAE;QACrE,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;QAC7B,OAAO,WAAW,CAAC,MAAM,CAAC,QAAQ,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAC5D,CAAC;IAED,OAAO;QACL,WAAW;QAEX,IAAI;YACF,OAAO,QAAQ,CAAC,IAAI,EAAE,CAAC;QACzB,CAAC;QAED,QAAQ;YACN,OAAO,YAAY,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;QACvC,CAAC;QAED,cAAc,CAAC,QAAQ;YACrB,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC;YAC5E,uEAAuE;YACvE,mEAAmE;YACnE,+DAA+D;YAC/D,MAAM,QAAQ,GAAG,iBAAiB,CAAC,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;YAC7D,OAAO,MAAM,CAAC,QAAQ,EAAE;gBACtB,GAAG,eAAe,CAAC,QAAQ,CAAC;gBAC5B,GAAG,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,eAAe,EAAE,QAAQ,EAAE,CAAC;aACjE,CAAC,CAAC;QACL,CAAC;QAED,aAAa,CAAC,OAAO;YACnB,MAAM,KAAK,GAAsB,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;YAExE,OAAO,MAAM,CAAC,OAAO,CAAC,QAAQ,IAAI,SAAS,CAAC,IAAI,EAAE;gBAChD,KAAK,EAAE,OAAO,CAAC,KAAK;gBACpB,GAAG,EAAE,OAAO,CAAC,GAAG;gBAChB,IAAI,EAAE,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE;gBAC1B,sEAAsE;gBACtE,sDAAsD;gBACtD,KAAK,EAAE,KAAK;gBACZ,UAAU,EAAE,EAAE,GAAG,OAAO,CAAC,UAAU,EAAE,KAAK,EAAE;gBAC5C,GAAG,CAAC,OAAO,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,CAAC;aAC3D,CAAC,CAAC;QACL,CAAC;QAED,cAAc,CAAC,GAAG;YAChB,OAAO,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE;gBAChC,KAAK,EAAE,WAAW;gBAClB,GAAG;gBACH,IAAI,EAAE,EAAE,GAAG,EAAE;aACd,CAAC,CAAC;QACL,CAAC;QAED,MAAM;KACP,CAAC;AACJ,CAAC"}

package/dist/web/routes.d.ts

@@ -0,0 +1,31 @@
+import type { Context, Hono } from 'hono';
+import type { GeekityEnv } from '../env.ts';
+import type { FeedFormat } from './feeds.ts';
+/** Where a paginated listing's later pages live, under any listing root. */
+export declare const PAGE_SEGMENT = "page";
+/** Root of the tag archives. */
+export declare const TAG_SEGMENT = "tags";
+/**
+ * Register the public site on a Hono app.
+ *
+ * The listings and the theme assets are routes; a document is resolved in the
+ * not-found handler instead. That ordering is deliberate: admin and federation
+ * routes registered after this one still win, and a permalink can never shadow
+ * them, because the document lookup only runs once nothing else has matched.
+ */
+export declare function mountPublicSite(app: Hono<GeekityEnv>): void;
+/** The URL of a page of the home listing, by zero-based index. */
+export declare function homeHref(index: number): string;
+/** The URL of a page of a tag archive, by zero-based index. */
+export declare function tagHref(tag: string, index: number): string;
+/** The URL of a feed: the whole archive's, or one tag's. */
+export declare function feedHref(tag: string | undefined, format: FeedFormat): string;
+/** The theme's 404 page. */
+export declare function notFound(c: Context<GeekityEnv>): Response;
+/**
+ * The requested path, percent-decoded, because permalinks are stored decoded.
+ * A path whose escapes are malformed is used as it arrived, which resolves to
+ * nothing and so 404s.
+ */
+export declare function requestPath(c: Context<GeekityEnv>): string;
+//# sourceMappingURL=routes.d.ts.map

package/dist/web/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/web/routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAI1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAgB5C,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,YAAY,CAAC;AAkBzD,4EAA4E;AAC5E,eAAO,MAAM,YAAY,SAAS,CAAC;AAEnC,gCAAgC;AAChC,eAAO,MAAM,WAAW,SAAS,CAAC;AAElC;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,IAAI,CAiC3D;AAqVD,kEAAkE;AAClE,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,+DAA+D;AAC/D,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAG1D;AAED,4DAA4D;AAC5D,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,UAAU,GAAG,MAAM,CAE5E;AAED,4BAA4B;AAC5B,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,QAAQ,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,MAAM,CAO1D"}

package/dist/web/routes.js

@@ -0,0 +1,366 @@
+import { serializeDocument } from '../content/writer.js';
+import { assetNotModified, assetResponse, findThemeAsset, findUpload, matchesEtag, themeAssetNotModified, themeAssetResponse, themeSearchPath, THEME_ASSET_PREFIX, UPLOAD_ASSET_MAX_AGE, UPLOAD_ASSET_PREFIX, } from './assets.js';
+import { isPublicDocument, publicDocumentAt } from './documents.js';
+import { feedResponse, feedSize, FEED_FILES } from './feeds.js';
+import { DOCUMENT_REPRESENTATIONS, documentJson, LISTING_REPRESENTATIONS, lastModifiedOf, latestModified, notAcceptableResponse, representationEtag, representationResponse, selectRepresentation, splitRepresentationExtension, } from './negotiate.js';
+import { offsetForPage, paginate } from './pagination.js';
+import { TEMPLATES } from './render.js';
+/** Where a paginated listing's later pages live, under any listing root. */
+export const PAGE_SEGMENT = 'page';
+/** Root of the tag archives. */
+export const TAG_SEGMENT = 'tags';
+/**
+ * Register the public site on a Hono app.
+ *
+ * The listings and the theme assets are routes; a document is resolved in the
+ * not-found handler instead. That ordering is deliberate: admin and federation
+ * routes registered after this one still win, and a permalink can never shadow
+ * them, because the document lookup only runs once nothing else has matched.
+ */
+export function mountPublicSite(app) {
+    app.get(`${THEME_ASSET_PREFIX}*`, themeAsset);
+    app.get(`${UPLOAD_ASSET_PREFIX}*`, upload);
+    app.get('/', (c) => listing(c, { tag: undefined, pageNumber: 0 }));
+    app.get(`/${PAGE_SEGMENT}/:page{[0-9]+}/`, (c) => {
+        const requested = Number(c.req.param('page'));
+        // Page one is the home page; it does not get a second URL.
+        if (requested <= 1)
+            return c.redirect('/', 301);
+        return listing(c, { tag: undefined, pageNumber: requested - 1 });
+    });
+    // Feeds are routes rather than representations, so a reader's careless
+    // `Accept` header cannot land it on the HTML (doc-3). They are registered
+    // before the tag archive so the shape of the URL, not the negotiator,
+    // decides what comes back.
+    app.get(`/${FEED_FILES.atom}`, (c) => feed(c, 'atom', undefined));
+    app.get(`/${FEED_FILES.json}`, (c) => feed(c, 'json', undefined));
+    app.get(`/${TAG_SEGMENT}/:tag/${FEED_FILES.atom}`, (c) => feed(c, 'atom', c.req.param('tag')));
+    app.get(`/${TAG_SEGMENT}/:tag/${FEED_FILES.json}`, (c) => feed(c, 'json', c.req.param('tag')));
+    app.get(`/${TAG_SEGMENT}/:tag/`, (c) => listing(c, { tag: c.req.param('tag'), pageNumber: 0 }));
+    app.get(`/${TAG_SEGMENT}/:tag/${PAGE_SEGMENT}/:page{[0-9]+}/`, (c) => {
+        const tag = c.req.param('tag');
+        const requested = Number(c.req.param('page'));
+        if (requested <= 1)
+            return c.redirect(tagHref(tag, 0), 301);
+        return listing(c, { tag, pageNumber: requested - 1 });
+    });
+    app.notFound(resolveDocument);
+}
+/**
+ * The last stop for a request: the document at this URL, the same document in
+ * the representation a `.md` or `.json` suffix asked for, the canonical URL it
+ * should have asked for, or the theme's 404.
+ *
+ * The suffix is stripped and the *same* {@link publicDocumentAt} lookup runs
+ * again, so no representation can resolve to a document the others cannot see.
+ */
+function resolveDocument(c) {
+    const { store } = c.var;
+    const pathname = requestPath(c);
+    const document = publicDocumentAt(store, pathname);
+    if (document !== undefined) {
+        return negotiateDocument(c, document, selectFromAccept(c, DOCUMENT_REPRESENTATIONS));
+    }
+    const extension = splitRepresentationExtension(pathname);
+    if (extension !== undefined) {
+        for (const candidate of extension.paths) {
+            const found = publicDocumentAt(store, candidate);
+            if (found !== undefined)
+                return negotiateDocument(c, found, extension.representation);
+        }
+        // `/index.json`, `/page/2/index.json`, `/tags/x/index.json`: the same
+        // escape hatch over a listing, for the representations a listing has.
+        if (LISTING_REPRESENTATIONS.includes(extension.representation)) {
+            for (const candidate of extension.paths) {
+                const request = parseListingPath(candidate);
+                if (request !== undefined)
+                    return listing(c, request, extension.representation);
+            }
+        }
+    }
+    const canonical = canonicalPath(c, pathname);
+    if (canonical !== undefined)
+        return c.redirect(canonical, 301);
+    return notFound(c);
+}
+/** The representation an `Accept` header asked for, or `undefined` for a 406. */
+function selectFromAccept(c, available) {
+    return selectRepresentation(c.req.header('accept'), available);
+}
+/** One document in one representation, or the 406 an impossible `Accept` earns. */
+function negotiateDocument(c, document, representation) {
+    if (representation === undefined) {
+        return notAcceptableResponse(encodePath(document.permalink), DOCUMENT_REPRESENTATIONS);
+    }
+    const body = representation === 'markdown'
+        ? serializeDocument(document)
+        : representation === 'json'
+            ? documentJson(document, { baseUrl: c.var.config.baseUrl })
+            : c.var.renderer.renderDocument(document);
+    // The theme can change without the document changing, and only the document
+    // is hashed. While the watcher is on — a development server, where a template
+    // edit lands mid-process — the HTML gets no validator rather than a stale one.
+    const validated = representation !== 'html' || !c.var.config.watch;
+    return representationResponse({
+        body,
+        representation,
+        href: encodePath(document.permalink),
+        available: DOCUMENT_REPRESENTATIONS,
+        ...(validated
+            ? {
+                etag: representationEtag(representation, document.hash),
+                lastModified: lastModifiedOf(document),
+            }
+            : {}),
+        conditional: conditionalHeaders(c),
+    });
+}
+/** The conditional request headers, as the negotiator wants them. */
+function conditionalHeaders(c) {
+    return {
+        ifNoneMatch: c.req.header('if-none-match'),
+        ifModifiedSince: c.req.header('if-modified-since'),
+    };
+}
+/**
+ * The canonical URL for a path that arrived without its trailing slash, or
+ * `undefined` when adding one would not resolve either.
+ *
+ * Redirecting only to somewhere real means a genuinely missing URL costs one
+ * 404 rather than a redirect and then a 404. The target is the canonical URL
+ * itself rather than the path with a slash bolted on, so `/page/1` lands on
+ * `/` in one hop instead of two.
+ */
+function canonicalPath(c, pathname) {
+    if (pathname === '' || pathname.endsWith('/'))
+        return undefined;
+    const target = canonicalTarget(c, `${pathname}/`);
+    if (target === undefined)
+        return undefined;
+    return `${target}${new URL(c.req.url).search}`;
+}
+/** Where a path with a trailing slash canonically lives, if anywhere. */
+function canonicalTarget(c, pathname) {
+    const { store, renderer } = c.var;
+    const document = store.getByPermalink(pathname);
+    if (document !== undefined) {
+        return isPublicDocument(document) ? encodePath(pathname) : undefined;
+    }
+    const listing = parseListingPath(pathname);
+    if (listing === undefined)
+        return undefined;
+    // The home listing exists even with nothing on it; a tag archive does not.
+    const total = listing.tag === undefined ? store.counts().posts : store.countByTag(listing.tag);
+    if (listing.tag !== undefined && total === 0)
+        return undefined;
+    const totalPages = Math.max(1, Math.ceil(total / renderer.pageSize()));
+    if (listing.pageNumber >= totalPages)
+        return undefined;
+    return listing.tag === undefined
+        ? homeHref(listing.pageNumber)
+        : tagHref(listing.tag, listing.pageNumber);
+}
+/** `/`, `/page/N/`, `/tags/x/` and `/tags/x/page/N/`, as a listing to check. */
+function parseListingPath(pathname) {
+    const segments = pathname.split('/').filter((segment) => segment !== '');
+    if (segments.length === 0)
+        return { tag: undefined, pageNumber: 0 };
+    if (segments[0] === PAGE_SEGMENT && segments.length === 2) {
+        const page = pageIndex(segments[1]);
+        return page === undefined ? undefined : { tag: undefined, pageNumber: page };
+    }
+    if (segments[0] !== TAG_SEGMENT || segments[1] === undefined)
+        return undefined;
+    const tag = segments[1];
+    if (segments.length === 2)
+        return { tag, pageNumber: 0 };
+    if (segments.length === 4 && segments[2] === PAGE_SEGMENT) {
+        const page = pageIndex(segments[3]);
+        return page === undefined ? undefined : { tag, pageNumber: page };
+    }
+    return undefined;
+}
+/**
+ * A `/page/N/` segment as a zero-based index. `page/1` parses to the first
+ * page, which lives at the listing root, so canonicalisation collapses it.
+ */
+function pageIndex(segment) {
+    if (segment === undefined || !/^[0-9]+$/.test(segment))
+        return undefined;
+    const requested = Number(segment);
+    return requested < 1 ? undefined : requested - 1;
+}
+/** One page of a listing, in whichever representation the request settled on. */
+function listing(c, request, representation = selectFromAccept(c, LISTING_REPRESENTATIONS)) {
+    const { store, renderer } = c.var;
+    const { tag } = request;
+    const size = renderer.pageSize();
+    // A tag archive only exists while something carries the tag; the home
+    // listing exists even with nothing on it.
+    const total = tag === undefined ? store.counts().posts : store.countByTag(tag);
+    if (tag !== undefined && total === 0)
+        return notFound(c);
+    const href = tag === undefined ? homeHref(request.pageNumber) : tagHref(tag, request.pageNumber);
+    const pagination = paginate({
+        total,
+        size,
+        pageNumber: request.pageNumber,
+        hrefForPage: (index) => (tag === undefined ? homeHref(index) : tagHref(tag, index)),
+    });
+    if (request.pageNumber >= pagination.totalPages)
+        return notFound(c);
+    if (representation === undefined)
+        return notAcceptableResponse(href, LISTING_REPRESENTATIONS);
+    const paging = { limit: size, offset: offsetForPage(request.pageNumber, size) };
+    const documents = tag === undefined ? store.listPosts(paging) : store.listByTag(tag, paging);
+    const full = wantsFullDocuments(c);
+    const body = representation === 'json'
+        ? documents.map((document) => documentJson(document, { baseUrl: c.var.config.baseUrl, body: full }))
+        : renderer.renderListing({
+            title: tag ?? renderer.site().title,
+            url: href,
+            documents,
+            pagination,
+            ...(tag === undefined ? {} : { tag, template: TEMPLATES.tag }),
+        });
+    const validated = representation !== 'html' || !c.var.config.watch;
+    return representationResponse({
+        body,
+        representation,
+        href,
+        available: LISTING_REPRESENTATIONS,
+        ...(validated
+            ? {
+                etag: representationEtag(representation, listingFingerprint(href, pagination, documents, full)),
+                lastModified: latestModified(documents),
+            }
+            : {}),
+        conditional: conditionalHeaders(c),
+    });
+}
+/**
+ * Whether the request asked for whole documents rather than summaries.
+ *
+ * Anything but an explicit denial counts, so `?full`, `?full=1` and `?full=yes`
+ * all mean the same thing to someone typing a URL by hand.
+ */
+function wantsFullDocuments(c) {
+    const value = c.req.query('full');
+    return value !== undefined && value !== '0' && value.toLowerCase() !== 'false';
+}
+/**
+ * What a listing page is made of, as one string to hash.
+ *
+ * The documents on the page are not the whole story: the same two posts on a
+ * differently sized archive are a different page, and a summary is not the
+ * body, so the pagination and the `full` flag are in the fingerprint too.
+ */
+function listingFingerprint(href, pagination, documents, full) {
+    return [
+        href,
+        `${String(pagination.pageNumber)}/${String(pagination.totalPages)}/${String(pagination.total)}`,
+        full ? 'full' : 'summary',
+        ...documents.map((document) => document.hash),
+    ].join('\n');
+}
+/**
+ * The site's feed, or one tag's, in one format.
+ *
+ * A tag with nothing published under it 404s exactly as its archive does: a
+ * feed reader should be told the URL is wrong rather than handed an empty feed
+ * it will poll forever.
+ */
+function feed(c, format, tag) {
+    const { store, renderer, config } = c.var;
+    const site = renderer.site();
+    if (tag !== undefined && store.countByTag(tag) === 0)
+        return notFound(c);
+    const documents = tag === undefined
+        ? store.listPosts({ limit: feedSize(site) })
+        : store.listByTag(tag, { limit: feedSize(site) });
+    const href = tag === undefined ? homeHref(0) : tagHref(tag, 0);
+    const source = {
+        site,
+        documents,
+        title: tag === undefined ? site.title : `${site.title}: ${tag}`,
+        href,
+        feedHref: feedHref(tag, format),
+        baseUrl: config.baseUrl,
+    };
+    return feedResponse({ format, source, conditional: conditionalHeaders(c) });
+}
+/**
+ * A file from the theme's `static/` directory, the site's copy first.
+ *
+ * Assets are cacheable and validated, so a browser that already has one pays a
+ * conditional request rather than a download.
+ */
+function themeAsset(c) {
+    const relative = requestPath(c).slice(THEME_ASSET_PREFIX.length);
+    const asset = findThemeAsset(relative, themeSearchPath(c.var.config.themeDir));
+    if (asset === undefined)
+        return notFound(c);
+    if (matchesEtag(c.req.header('if-none-match'), asset.etag)) {
+        return themeAssetNotModified(asset);
+    }
+    return themeAssetResponse(asset);
+}
+/**
+ * A file from `content/uploads/`, at the URL Eleventy's passthrough copy puts
+ * it at.
+ *
+ * Uploads are not documents — the index never sees them — so they are served
+ * as files, with the same validators and the same traversal check the theme's
+ * assets get. The cache lifetime is longer than a theme asset's because an
+ * upload's URL names one set of bytes: the upload endpoint never overwrites,
+ * it suffixes.
+ */
+function upload(c) {
+    const relative = requestPath(c).slice(UPLOAD_ASSET_PREFIX.length);
+    const asset = findUpload(relative, c.var.config.contentDir);
+    if (asset === undefined)
+        return notFound(c);
+    const options = { maxAge: UPLOAD_ASSET_MAX_AGE };
+    return matchesEtag(c.req.header('if-none-match'), asset.etag)
+        ? assetNotModified(asset, options)
+        : assetResponse(asset, options);
+}
+/** The URL of a page of the home listing, by zero-based index. */
+export function homeHref(index) {
+    return index === 0 ? '/' : `/${PAGE_SEGMENT}/${String(index + 1)}/`;
+}
+/** The URL of a page of a tag archive, by zero-based index. */
+export function tagHref(tag, index) {
+    const root = `/${TAG_SEGMENT}/${encodeURIComponent(tag)}/`;
+    return index === 0 ? root : `${root}${PAGE_SEGMENT}/${String(index + 1)}/`;
+}
+/** The URL of a feed: the whole archive's, or one tag's. */
+export function feedHref(tag, format) {
+    return tag === undefined ? `/${FEED_FILES[format]}` : `${tagHref(tag, 0)}${FEED_FILES[format]}`;
+}
+/** The theme's 404 page. */
+export function notFound(c) {
+    return c.html(c.var.renderer.renderNotFound(requestPath(c)), 404);
+}
+/**
+ * The requested path, percent-decoded, because permalinks are stored decoded.
+ * A path whose escapes are malformed is used as it arrived, which resolves to
+ * nothing and so 404s.
+ */
+export function requestPath(c) {
+    const { pathname } = new URL(c.req.url);
+    try {
+        return decodeURIComponent(pathname);
+    }
+    catch {
+        return pathname;
+    }
+}
+/** A decoded path back into one safe to put in a `Location` header. */
+function encodePath(pathname) {
+    return pathname
+        .split('/')
+        .map((segment) => encodeURIComponent(segment))
+        .join('/');
+}
+//# sourceMappingURL=routes.js.map