@gjsify/site 0.64.11 → 0.64.12-next.279

package/lib/render/blog.js

@@ -0,0 +1,240 @@
+/**
+ * The blog: an index per language, one page per post, a page and a feed per tag, and the "latest
+ * posts" section an app's landing page shows. Every page renders through `layout.ts`, so a blog on
+ * an app site and one on a developer site look the same (ADR 0120 §4).
+ */
+import { posix } from 'node:path';
+import { tagSlug } from '../site-data/index.js';
+import { atomFeed } from './feed.js';
+import { esc, fmt, plain } from './html.js';
+import { icon } from './icons.js';
+import { absoluteUrl, documentPage, pageMasthead, sitePageUrl } from './layout.js';
+import { renderMarkdown } from './markdown.js';
+import { blogPostingJsonLd, metaDescription } from './seo.js';
+/** How many posts an app's landing page shows. */
+export const LATEST_POSTS = 3;
+export function blogIndexUrl(config, lang) {
+    return sitePageUrl(config, lang, 'blog/');
+}
+export function blogFeedUrl(config, lang, tag) {
+    return sitePageUrl(config, lang, tag ? `blog/tags/${tagSlug(tag)}/feed.xml` : 'blog/feed.xml');
+}
+export function postUrl(config, post) {
+    return sitePageUrl(config, post.lang, `blog/${post.slug}/`);
+}
+export function tagUrl(config, lang, tag) {
+    return sitePageUrl(config, lang, `blog/tags/${tagSlug(tag)}/`);
+}
+/** The post's own link-preview card, written next to its page. */
+export function postOgImage(config, post) {
+    return `${postUrl(config, post)}og.png`;
+}
+const ABSOLUTE = /^(?:[a-z][a-z0-9+.-]*:|\/|#)/i;
+/**
+ * Rewrites the URLs a post's Markdown names. A relative image or file resolves against the post's
+ * own directory below `<base>blog/` — where the build copies the asset files. A relative link to
+ * another post's `.md` file becomes that post's page, so a writer links files the way the editor
+ * shows them and the published page links pages.
+ */
+export function postUrlResolver(config, post, postsDir, posts) {
+    const own = posix.dirname(posix.relative(toPosix(postsDir), toPosix(post.file)));
+    const byFile = new Map(posts.map((other) => [posix.relative(toPosix(postsDir), toPosix(other.file)), other]));
+    return (url) => {
+        if (ABSOLUTE.test(url))
+            return url;
+        const [path = '', hash] = url.split('#', 2);
+        const target = posix.normalize(posix.join(own, decodeURI(path)));
+        if (target.startsWith('..'))
+            return url;
+        if (path.endsWith('.md')) {
+            const linked = byFile.get(target);
+            // The build never publishes Markdown, so a link to a post it does not render is dead.
+            if (!linked)
+                throw new Error(`${post.file}: links to ${path}, which is not a published post (a draft?)`);
+            return `${postUrl(config, linked)}${hash ? `#${hash}` : ''}`;
+        }
+        return `${config.base}blog/${encodeURI(target)}${hash ? `#${hash}` : ''}`;
+    };
+}
+function toPosix(path) {
+    return path.split('\\').join('/');
+}
+export function formatPostDate(date, lang) {
+    const time = /^\d{4}-\d{2}-\d{2}$/.test(date) ? `${date}T00:00:00Z` : date;
+    return new Intl.DateTimeFormat(lang, { dateStyle: 'long', timeZone: 'UTC' }).format(new Date(time));
+}
+/** The first paragraph of the Markdown body, reduced to its text. */
+function firstParagraph(body) {
+    const paragraph = body
+        .split(/\n\s*\n/)
+        .map((block) => block.trim())
+        .find((block) => block !== '' && !/^(?:#|!\[|```|~~~|>|[-*+] |\d+\. |\||<)/.test(block));
+    return paragraph
+        ?.replace(/!?\[([^\]]*)\]\([^)]*\)/g, '$1')
+        .replace(/[*_`]/g, '')
+        .replace(/\s+/g, ' ');
+}
+/** `summary`, or the start of the body when the post has none. */
+export function postDescription(post) {
+    return post.summary ?? metaDescription('', firstParagraph(post.body));
+}
+function postMeta(post, shell) {
+    const { config, lang, t } = shell;
+    const tags = post.tags.map((tag) => `<li><a class="tag" href="${esc(tagUrl(config, lang, tag))}" rel="tag">${esc(tag)}</a></li>`);
+    const updated = post.updated && post.updated !== post.date
+        ? ` · ${fmt(t('Updated {date}'), { date: formatPostDate(post.updated, lang) })}`
+        : '';
+    return `<p class="post-meta"><time datetime="${esc(post.date)}">${esc(formatPostDate(post.date, lang))}</time>${updated}${post.draft ? ` · <strong>${esc(t('Draft'))}</strong>` : ''}</p>
+${tags.length > 0 ? `<ul class="post-tags">${tags.join('')}</ul>` : ''}`;
+}
+function postCard(shell, post, heading) {
+    const description = postDescription(post);
+    return `<li><article class="post-card">
+<${heading}><a href="${esc(postUrl(shell.config, post))}">${esc(post.title)}</a></${heading}>
+${postMeta(post, shell)}
+${description ? `<p>${esc(description)}</p>` : ''}
+</article></li>`;
+}
+function feedLink(shell, href) {
+    return `<p class="post-feed"><a href="${esc(href)}">${icon('feed')}<span>${esc(shell.t('Subscribe to the feed'))}</span></a></p>`;
+}
+/** `/<lang>/blog/` or `/<lang>/blog/tags/<tag>/`. */
+export function renderBlogIndex(shell, options) {
+    const { config, lang, t } = shell;
+    const { tag } = options;
+    const inLanguage = options.posts.filter((post) => post.lang === lang && (tag === undefined || post.tags.includes(tag)));
+    const urls = {};
+    // Every language has an index, if an empty one; a tag page exists only where the tag is used.
+    for (const code of config.languages) {
+        if (tag === undefined)
+            urls[code] = blogIndexUrl(config, code);
+        else if (code === lang || options.posts.some((post) => post.lang === code && post.tags.includes(tag)))
+            urls[code] = tagUrl(config, code, tag);
+    }
+    const heading = tag ? plain(t('Posts tagged “{tag}”'), { tag }) : t('Blog');
+    const page = {
+        title: `${shell.name} – ${heading}`,
+        description: tag ? heading : plain(t('Posts by {name}'), { name: shell.name }),
+        urls,
+        fallback: (code) => blogIndexUrl(config, code),
+        ogImage: options.ogImage,
+    };
+    const list = inLanguage.length > 0
+        ? `<ul class="post-list">\n${inLanguage.map((post) => postCard(shell, post, 'h2')).join('\n')}\n</ul>`
+        : `<p class="post-empty">${esc(t('No posts in this language yet.'))}</p>`;
+    const back = tag
+        ? `\n<p class="support-back"><a href="${esc(blogIndexUrl(config, lang))}">${esc(t('All posts'))}</a></p>`
+        : '';
+    return documentPage(shell, page, `${pageMasthead(shell, heading, shell.name)}
+<main>
+<div class="column blog">
+${list}
+${feedLink(shell, blogFeedUrl(config, lang, tag))}${back}
+</div>
+</main>`);
+}
+/** `/<lang>/blog/<slug>/`. */
+export function renderBlogPost(shell, post, options) {
+    const { config, lang, t } = shell;
+    const urls = {};
+    for (const other of options.posts)
+        if (other.slug === post.slug)
+            urls[other.lang] = postUrl(config, other);
+    const description = postDescription(post);
+    const url = absoluteUrl(config, postUrl(config, post));
+    const ogImage = postOgImage(config, post);
+    const page = {
+        title: `${post.title} – ${shell.name}`,
+        description,
+        urls,
+        fallback: (code) => blogIndexUrl(config, code),
+        ogType: 'article',
+        ogImage,
+        meta: [
+            ['article:published_time', post.date],
+            ...(post.updated ? [['article:modified_time', post.updated]] : []),
+            ...post.tags.map((tag) => ['article:tag', tag]),
+        ],
+        jsonLd: blogPostingJsonLd({
+            title: post.title,
+            description,
+            url,
+            published: post.date,
+            updated: post.updated,
+            author: options.author.name,
+            authorUrl: options.author.url,
+            image: absoluteUrl(config, ogImage),
+            lang,
+            tags: post.tags,
+        }),
+    };
+    return documentPage(shell, page, `<main>
+<article class="column post">
+<header class="post-head">
+<p class="post-back"><a href="${esc(blogIndexUrl(config, lang))}">${icon('chevron-left')}<span>${esc(t('Blog'))}</span></a></p>
+<h1>${esc(post.title)}</h1>
+${postMeta(post, shell)}
+</header>
+<div class="post-body">
+${options.html}
+</div>
+</article>
+</main>`, 'blog-post');
+}
+/** The newest posts as a landing-page section; empty when the language has none. */
+export function latestPostsSection(shell, posts, count = LATEST_POSTS) {
+    const { config, lang, t } = shell;
+    const latest = posts.filter((post) => post.lang === lang).slice(0, count);
+    if (latest.length === 0)
+        return '';
+    return `<section class="latest-posts">
+<h2>${esc(t('From the blog'))}</h2>
+<ul class="post-list">
+${latest.map((post) => postCard(shell, post, 'h3')).join('\n')}
+</ul>
+<p class="post-feed"><a href="${esc(blogIndexUrl(config, lang))}">${esc(t('All posts'))}</a></p>
+</section>`;
+}
+export function postKey(post) {
+    return `${post.lang}/${post.slug}`;
+}
+/** The Atom feed of one language, or of one tag in it. Relative URLs in the content are made absolute. */
+export function renderBlogFeed(shell, options) {
+    const { config, lang, t } = shell;
+    const { tag } = options;
+    const posts = options.posts.filter((post) => post.lang === lang && (tag === undefined || post.tags.includes(tag)));
+    const origin = `${new URL(config.url).origin}`;
+    const absolutize = (html) => html.replace(/(\s(?:href|src)=")\//g, `$1${origin}/`);
+    const entries = posts.map((post) => {
+        const url = absoluteUrl(config, postUrl(config, post));
+        return {
+            id: url,
+            url,
+            title: post.title,
+            published: post.date,
+            updated: post.updated,
+            summary: post.summary,
+            contentHtml: absolutize(options.html.get(postKey(post)) ?? ''),
+            tags: post.tags,
+        };
+    });
+    const site = absoluteUrl(config, tag ? tagUrl(config, lang, tag) : blogIndexUrl(config, lang));
+    const self = absoluteUrl(config, blogFeedUrl(config, lang, tag));
+    return atomFeed({
+        id: self,
+        title: tag ? `${shell.name} – ${tag}` : `${shell.name} – ${t('Blog')}`,
+        selfUrl: self,
+        siteUrl: site,
+        lang,
+        author: options.author,
+        icon: options.iconUrl ? absoluteUrl(config, options.iconUrl) : undefined,
+    }, entries);
+}
+/** Every tag in one language, in first-use order. */
+export function tagsOf(posts, lang) {
+    return [...new Set(posts.filter((post) => post.lang === lang).flatMap((post) => post.tags))];
+}
+/** Renders a post's Markdown with its URLs resolved. */
+export function renderPostBody(config, post, postsDir, posts) {
+    return renderMarkdown(post.body, { resolveUrl: postUrlResolver(config, post, postsDir, posts) });
+}

package/lib/render/developer.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A developer site: the hub at `/<lang>/` — who the person is, the apps they publish, the latest
+ * posts — and the CV at `/<lang>/cv/`, both from a JSON Resume file per language (ADR 0120 §3).
+ * The support, privacy and legal-notice pages are the app site's, under the person's name.
+ */
+import type { DeveloperData } from '../site-data/index.js';
+import { type ClientAssets, type Shell, type Translate } from './layout.js';
+export interface DeveloperContext {
+    data: DeveloperData;
+    lang: string;
+    t: Translate;
+    assets: ClientAssets;
+    /** Published URL of `basics.image`: the avatar, the favicon and the bar brand. */
+    avatarUrl?: string;
+    displayFontUrl?: string;
+    /** Root-relative URL of the link-preview card for this language. */
+    ogImage?: string;
+}
+export type DeveloperView = 'home' | 'cv' | 'support' | 'privacy' | 'legal-notice';
+export declare function developerPageUrl(ctx: Pick<DeveloperContext, 'data'>, lang: string, view: DeveloperView): string;
+export declare function developerShell(ctx: DeveloperContext, current?: 'blog' | 'cv'): Shell;
+/** `/<lang>/`: the person, their apps, their latest posts. */
+export declare function renderDeveloperHome(ctx: DeveloperContext, latestPosts?: string): string;
+/** `2024-03` → "March 2024" in the reader's language; a bare year stays a year. */
+export declare function formatResumeDate(date: string, lang: string): string;
+/** `/<lang>/cv/`: the résumé, one column on screen, without the site's chrome on paper. */
+export declare function renderCv(ctx: DeveloperContext): string;
+export declare function renderDeveloperSupportPage(ctx: DeveloperContext): string;
+export declare function renderDeveloperPrivacyPage(ctx: DeveloperContext, statement: string): string;
+export declare function renderDeveloperLegalNoticePage(ctx: DeveloperContext, statement: string): string;

package/lib/render/developer.js

@@ -0,0 +1,285 @@
+import { blogFeedUrl, blogIndexUrl } from './blog.js';
+import { esc, fmt, plain } from './html.js';
+import { icon } from './icons.js';
+import { absoluteUrl, documentPage, githubUrl, simplePage, sitePageUrl, } from './layout.js';
+import { renderMarkdown } from './markdown.js';
+import { hostingNotice, linkCard, relatedCard, supportList } from './pages.js';
+import { personJsonLd } from './seo.js';
+const VIEW_PATHS = {
+    home: '',
+    cv: 'cv/',
+    support: 'support/',
+    privacy: 'privacy/',
+    'legal-notice': 'legal-notice/',
+};
+export function developerPageUrl(ctx, lang, view) {
+    return sitePageUrl(ctx.data.config, lang, VIEW_PATHS[view]);
+}
+function resume(ctx) {
+    return ctx.data.resumes[ctx.lang];
+}
+export function developerShell(ctx, current) {
+    const { data, lang, t } = ctx;
+    const { config } = data;
+    const name = resume(ctx).basics.name;
+    const nav = [
+        ...(config.blog
+            ? [
+                {
+                    href: blogIndexUrl(config, lang),
+                    label: t('Blog'),
+                    glyph: 'blog',
+                    current: current === 'blog',
+                },
+            ]
+            : []),
+        { href: developerPageUrl(ctx, lang, 'cv'), label: t('CV'), glyph: 'cv', current: current === 'cv' },
+    ];
+    return {
+        config,
+        lang,
+        t,
+        assets: ctx.assets,
+        name,
+        home: developerPageUrl(ctx, lang, 'home'),
+        iconUrl: ctx.avatarUrl,
+        // No metainfo `<branding>` to read, so the accent is the developer's colour.
+        branding: config.theme.accent ?? {},
+        repository: githubUrl(config.repository),
+        licenses: [],
+        nav,
+        feeds: config.blog ? [{ title: `${name} – ${t('Blog')}`, href: blogFeedUrl(config, lang) }] : [],
+        displayFontUrl: ctx.displayFontUrl,
+    };
+}
+function pageMetaFor(ctx, view, title, description) {
+    const { config } = ctx.data;
+    return {
+        title,
+        description,
+        urls: Object.fromEntries(config.languages.map((code) => [code, developerPageUrl(ctx, code, view)])),
+        ogType: view === 'home' || view === 'cv' ? 'profile' : 'website',
+        ogImage: ctx.ogImage,
+    };
+}
+const PROFILE_GLYPHS = {
+    github: 'code',
+    gitlab: 'code',
+    codeberg: 'code',
+    sourcehut: 'code',
+    mastodon: 'people',
+    linkedin: 'people',
+    xing: 'people',
+    email: 'mail',
+};
+function profileGlyph(profile) {
+    return PROFILE_GLYPHS[profile.network.toLowerCase()] ?? 'external';
+}
+function profileLinks(profiles) {
+    return profiles
+        .filter((profile) => profile.url)
+        .map((profile) => linkCard(profile.url, profile.network, profileGlyph(profile)));
+}
+/** The words a search result shows: the label and the start of the summary. */
+function developerDescription(resume) {
+    const { label, summary, name } = resume.basics;
+    const text = [label, summary].filter(Boolean).join(' – ');
+    if (!text)
+        return name;
+    return text.length <= 160 ? text : `${text.slice(0, 159).replace(/\s+\S*$/, '')}…`;
+}
+function hero(ctx) {
+    const { basics } = resume(ctx);
+    const avatar = ctx.avatarUrl
+        ? `<div class="hero-icon developer-avatar"><img src="${esc(ctx.avatarUrl)}" alt="" width="128" height="128"></div>`
+        : '';
+    return `<header class="masthead">
+<div class="hero-inner">
+${avatar}
+<div class="hero-text">
+<h1>${esc(basics.name)}</h1>
+${basics.label ? `<p class="hero-by">${esc(basics.label)}</p>` : ''}
+</div>
+</div>
+</header>`;
+}
+/** `/<lang>/`: the person, their apps, their latest posts. */
+export function renderDeveloperHome(ctx, latestPosts = '') {
+    const { data, lang, t } = ctx;
+    const cv = resume(ctx);
+    const { basics } = cv;
+    const description = developerDescription(cv);
+    const page = pageMetaFor(ctx, 'home', basics.label ? `${basics.name} – ${basics.label}` : basics.name, description);
+    page.jsonLd = personJsonLd({
+        name: basics.name,
+        url: absoluteUrl(data.config, developerPageUrl(ctx, lang, 'home')),
+        jobTitle: basics.label,
+        description: basics.summary,
+        image: ctx.avatarUrl ? absoluteUrl(data.config, ctx.avatarUrl) : undefined,
+        sameAs: basics.profiles.flatMap((profile) => (profile.url ? [profile.url] : [])),
+    });
+    const profiles = profileLinks(basics.profiles);
+    const apps = data.apps.length > 0
+        ? `<section class="related developer-apps">
+<h2>${esc(t('Apps'))}</h2>
+<ul class="related-list">
+${data.apps.map((app) => relatedCard(app, lang)).join('\n')}
+</ul>
+</section>`
+        : '';
+    const support = data.config.support.length > 0
+        ? `<section class="support">
+<a class="button support-cta" href="${esc(developerPageUrl(ctx, lang, 'support'))}">${icon('heart')}<span>${esc(t('Support my work'))}</span></a>
+</section>`
+        : '';
+    return documentPage(developerShell(ctx), page, `${hero(ctx)}
+<main>
+<div class="column">
+<section class="about">
+${basics.summary ? renderMarkdown(basics.summary) : ''}
+<p class="developer-cv"><a class="button" href="${esc(developerPageUrl(ctx, lang, 'cv'))}">${icon('cv')}<span>${esc(t('Read my CV'))}</span></a></p>
+</section>
+${apps}
+${latestPosts}
+${support}
+${profiles.length > 0 ? `<section class="links">\n<h2>${esc(t('Elsewhere'))}</h2>\n<ul class="card-list">\n${profiles.join('\n')}\n</ul>\n</section>` : ''}
+</div>
+</main>`, 'developer');
+}
+/** `2024-03` → "March 2024" in the reader's language; a bare year stays a year. */
+export function formatResumeDate(date, lang) {
+    const [year, month] = date.split('-');
+    if (!month)
+        return year;
+    return new Intl.DateTimeFormat(lang, { month: 'long', year: 'numeric', timeZone: 'UTC' }).format(new Date(Date.UTC(Number(year), Number(month) - 1, 1)));
+}
+function period(start, end, lang, t) {
+    if (!start && !end)
+        return '';
+    const from = start ? formatResumeDate(start, lang) : '';
+    const to = end ? formatResumeDate(end, lang) : t('today');
+    const text = from ? `${from} – ${to}` : to;
+    return `<p class="cv-period">${start ? `<time datetime="${esc(start)}">` : ''}${esc(text)}${start ? '</time>' : ''}</p>`;
+}
+function highlights(items) {
+    return items.length > 0
+        ? `<ul class="cv-highlights">${items.map((item) => `<li>${esc(item)}</li>`).join('')}</ul>`
+        : '';
+}
+function titled(name, url) {
+    return url ? `<a href="${esc(url)}">${esc(name)}</a>` : esc(name);
+}
+function workEntry(work, lang, t) {
+    return `<li class="cv-entry">
+<h3>${work.position ? `${esc(work.position)} · ` : ''}${titled(work.name, work.url)}</h3>
+${period(work.startDate, work.endDate, lang, t)}
+${work.summary ? `<p>${esc(work.summary)}</p>` : ''}
+${highlights(work.highlights)}
+</li>`;
+}
+function projectEntry(project, lang, t) {
+    return `<li class="cv-entry">
+<h3>${titled(project.name, project.url)}</h3>
+${period(project.startDate, project.endDate, lang, t)}
+${project.description ? `<p>${esc(project.description)}</p>` : ''}
+${highlights(project.highlights)}
+${project.keywords.length > 0 ? `<ul class="tags">${project.keywords.map((keyword) => `<li>${esc(keyword)}</li>`).join('')}</ul>` : ''}
+</li>`;
+}
+function educationEntry(education, lang, t) {
+    const what = [education.studyType, education.area].filter(Boolean).join(', ');
+    return `<li class="cv-entry">
+<h3>${what ? `${esc(what)} · ` : ''}${titled(education.institution, education.url)}</h3>
+${period(education.startDate, education.endDate, lang, t)}
+</li>`;
+}
+function cvSection(className, heading, items) {
+    if (items.length === 0)
+        return '';
+    return `<section class="cv-section ${className}">
+<h2>${esc(heading)}</h2>
+<ul class="cv-list">
+${items.join('\n')}
+</ul>
+</section>`;
+}
+/** `/<lang>/cv/`: the résumé, one column on screen, without the site's chrome on paper. */
+export function renderCv(ctx) {
+    const { lang, t } = ctx;
+    const cv = resume(ctx);
+    const { basics } = cv;
+    const location = [basics.location?.city, basics.location?.region].filter(Boolean).join(', ');
+    const contact = [
+        basics.email ? `<li>${icon('mail')}<a href="mailto:${esc(basics.email)}">${esc(basics.email)}</a></li>` : '',
+        basics.url
+            ? `<li>${icon('web')}<a href="${esc(basics.url)}">${esc(basics.url.replace(/^https?:\/\/|\/$/g, ''))}</a></li>`
+            : '',
+        location ? `<li>${esc(location)}</li>` : '',
+        ...basics.profiles
+            .filter((profile) => profile.url)
+            .map((profile) => `<li>${icon(profileGlyph(profile))}<a href="${esc(profile.url)}">${esc(profile.username ?? profile.network)}</a></li>`),
+    ].filter(Boolean);
+    const skills = cv.skills.map((skill) => `<li class="cv-entry"><h3>${esc(skill.name)}</h3>${skill.keywords.length > 0 ? `<ul class="tags">${skill.keywords.map((keyword) => `<li>${esc(keyword)}</li>`).join('')}</ul>` : ''}</li>`);
+    const languages = cv.languages.map((language) => `<li class="cv-entry"><h3>${esc(language.language)}</h3>${language.fluency ? `<p>${esc(language.fluency)}</p>` : ''}</li>`);
+    const page = pageMetaFor(ctx, 'cv', `${t('CV')} – ${basics.name}`, plain(t('Experience, projects and skills of {name}.'), { name: basics.name }));
+    return documentPage(developerShell(ctx, 'cv'), page, `<main>
+<article class="column cv">
+<header class="cv-head">
+${ctx.avatarUrl ? `<img class="cv-avatar" src="${esc(ctx.avatarUrl)}" alt="" width="96" height="96">` : ''}
+<div>
+<h1>${esc(basics.name)}</h1>
+${basics.label ? `<p class="cv-label">${esc(basics.label)}</p>` : ''}
+${contact.length > 0 ? `<ul class="cv-contact">${contact.join('')}</ul>` : ''}
+</div>
+</header>
+${basics.summary ? `<section class="cv-section cv-summary">${renderMarkdown(basics.summary)}</section>` : ''}
+${cvSection('cv-work', t('Experience'), cv.work.map((work) => workEntry(work, lang, t)))}
+${cvSection('cv-projects', t('Projects'), cv.projects.map((project) => projectEntry(project, lang, t)))}
+${cvSection('cv-education', t('Education'), cv.education.map((education) => educationEntry(education, lang, t)))}
+${cvSection('cv-skills', t('Skills'), skills)}
+${cvSection('cv-languages', t('Languages'), languages)}
+</article>
+</main>`, 'cv-page');
+}
+function back(ctx) {
+    return {
+        href: developerPageUrl(ctx, ctx.lang, 'home'),
+        label: fmt(ctx.t('Back to {app}'), { app: resume(ctx).basics.name }),
+    };
+}
+export function renderDeveloperSupportPage(ctx) {
+    const { data, t } = ctx;
+    const name = resume(ctx).basics.name;
+    const description = plain(t('{name} writes free software. Support the work with a transfer or a service.'), {
+        name,
+    });
+    return simplePage(developerShell(ctx), pageMetaFor(ctx, 'support', `${t('Support')} – ${name}`, description), {
+        heading: t('Support'),
+        byline: name,
+        body: `<p class="support-intro">${esc(description)}</p>
+${supportList(data.config.support, t, name)}`,
+        back: back(ctx),
+    });
+}
+export function renderDeveloperPrivacyPage(ctx, statement) {
+    const { t } = ctx;
+    const name = resume(ctx).basics.name;
+    return simplePage(developerShell(ctx), pageMetaFor(ctx, 'privacy', `${t('Privacy')} – ${name}`, plain(t('What {app} does with data.'), { app: name })), {
+        heading: t('Privacy'),
+        byline: name,
+        columnClass: 'privacy-statement',
+        body: `${hostingNotice(ctx.data.config, t)}\n${renderMarkdown(statement)}`,
+        back: back(ctx),
+    });
+}
+export function renderDeveloperLegalNoticePage(ctx, statement) {
+    const { t } = ctx;
+    const name = resume(ctx).basics.name;
+    return simplePage(developerShell(ctx), pageMetaFor(ctx, 'legal-notice', `${t('Legal Notice')} – ${name}`, plain(t('Who publishes {app}, and how to reach them.'), { app: name })), {
+        heading: t('Legal Notice'),
+        byline: name,
+        columnClass: 'privacy-statement',
+        body: renderMarkdown(statement),
+        back: back(ctx),
+    });
+}

package/lib/render/feed.d.ts

@@ -0,0 +1,25 @@
+export interface FeedEntry {
+    id: string;
+    url: string;
+    title: string;
+    published: string;
+    updated?: string;
+    summary?: string;
+    contentHtml: string;
+    tags: readonly string[];
+}
+export interface FeedInfo {
+    id: string;
+    title: string;
+    subtitle?: string;
+    selfUrl: string;
+    siteUrl: string;
+    lang: string;
+    author: {
+        name: string;
+        uri?: string;
+    };
+    icon?: string;
+}
+/** A complete Atom document. Dates are given as YYYY-MM-DD or ISO; output RFC 3339 (date-only → T00:00:00Z). Feed <updated> = newest entry updated/published, or 1970-01-01T00:00:00Z when empty. */
+export declare function atomFeed(info: FeedInfo, entries: readonly FeedEntry[]): string;