@geekity/cms 0.3.0

package/dist/admin/settings.d.ts

@@ -0,0 +1,194 @@
+import type { Hono } from 'hono';
+import type { ResolvedConfig } from '../config.ts';
+import type { GeekityEnv } from '../env.ts';
+import type { SiteData } from '../web/context.ts';
+import type { AdminRender } from './documents.ts';
+import type { AdminStore } from './store.ts';
+/** Where the settings screen lives. */
+export declare const SETTINGS_PATH = "/admin/settings";
+/** Where the avatar's upload form and its Remove button post. */
+export declare const AVATAR_PATH = "/admin/settings/avatar";
+/** The fields those two forms submit. */
+export declare const AVATAR_FIELDS: {
+    readonly file: 'avatar';
+    readonly action: 'action';
+};
+/** The {@link AVATAR_FIELDS.action} that takes the avatar down again. */
+export declare const AVATAR_REMOVE = "remove";
+/**
+ * The ActivityPub actor types doc-4 allows a site to be.
+ *
+ * `Person` is first because it is the default: some clients hide `Service`
+ * actors from timelines, which is the wrong thing for a personal blog.
+ */
+export declare const ACTOR_TYPES: readonly string[];
+/**
+ * What an actor handle may be made of. Tighter than a username: the handle
+ * becomes the local part of `@handle@host` in WebFinger and in every mention
+ * somebody types, so it holds no punctuation that would need escaping there.
+ */
+export declare const ACTOR_HANDLE_PATTERN: RegExp;
+/**
+ * The settings the admin owns, doc-1's "data that lives only in SQLite".
+ *
+ * They are the source of truth once a site has booted once. The public subset
+ * is mirrored to `content/_data/site.json` on every save so an Eleventy build
+ * of the same content directory renders with the same values.
+ */
+export interface SiteSettings {
+    /** Site title, shown in the header, the `<title>` and the feeds. */
+    title: string;
+    /** One-line description under the title. May be empty. */
+    tagline: string;
+    /**
+     * Public origin. Whether it is the one in effect depends on
+     * {@link ResolvedConfig.baseUrlSource}; see {@link effectiveBaseUrl}.
+     */
+    baseUrl: string;
+    /** An IANA zone name, e.g. `Europe/London`. */
+    timezone: string;
+    /** How many posts a listing page holds. A positive integer. */
+    postsPerPage: number;
+    /** Site author, used as the feed author. May be empty. */
+    author: string;
+    /** The local part of the ActivityPub handle, `@{handle}@{host}` (doc-4). */
+    actorHandle: string;
+    /** Which ActivityPub actor type the site is, one of {@link ACTOR_TYPES}. */
+    actorType: string;
+    /**
+     * The site's avatar, as the public path the upload endpoint handed back —
+     * `/uploads/2026/09/me.png` — or an absolute URL for one hosted elsewhere.
+     * Empty when the site has none.
+     *
+     * It is not a field of the settings form: an image is uploaded and removed
+     * through {@link AVATAR_PATH}, because a file cannot travel in a urlencoded
+     * body and because a save of the other fields must not silently drop it.
+     */
+    avatar: string;
+}
+/**
+ * The settings the form on the settings screen carries.
+ *
+ * Every setting but the avatar, which is a file rather than a field; see
+ * {@link SiteSettings.avatar}.
+ */
+export type SettingsField = Exclude<keyof SiteSettings, 'avatar'>;
+/**
+ * What a site is worth before anybody has said otherwise.
+ *
+ * `baseUrl` is empty rather than a guess: only the resolved config knows what
+ * port the site is on, so the fallback is applied where the config is in hand.
+ */
+export declare const DEFAULT_SITE_SETTINGS: SiteSettings;
+/** The form field each setting is submitted under. */
+export declare const SETTINGS_FIELDS: {
+    readonly title: 'title';
+    readonly tagline: 'tagline';
+    readonly baseUrl: 'base_url';
+    readonly timezone: 'timezone';
+    readonly postsPerPage: 'posts_per_page';
+    readonly author: 'author';
+    readonly actorHandle: 'actor_handle';
+    readonly actorType: 'actor_type';
+};
+/** A submitted settings form, before it is known to be valid. */
+export type SettingsForm = Record<SettingsField, string>;
+/** One message per field that is wrong. An empty object is a valid form. */
+export type SettingsProblems = Partial<Record<SettingsField, string>>;
+/** The stored settings, with every default filled in. */
+export declare function readSiteSettings(store: AdminStore): SiteSettings;
+/** Write a whole settings object back to the store. */
+export declare function writeSiteSettings(store: AdminStore, settings: SiteSettings): void;
+/**
+ * The settings as the `site` global, for the theme and for the JSON mirror.
+ *
+ * Empty strings are left out rather than written as empty values, so a key a
+ * site keeps in `site.json` by hand and leaves blank in the form is overlaid
+ * rather than blanked.
+ */
+export declare function settingsSiteData(settings: SiteSettings): Partial<SiteData>;
+/**
+ * `content/_data/site.json` as it should read for these settings.
+ *
+ * Every key the form manages is written whether or not it has a value, so the
+ * file's shape is stable and an Eleventy template may reference `site.author`
+ * without guarding it. Every other key the file already had is kept: a site
+ * may put anything in there and reach it from its templates, and the settings
+ * form is not going to be the thing that throws it away.
+ */
+export declare function siteJsonFor(settings: SiteSettings, existing?: Record<string, unknown>): Record<string, unknown>;
+/** The absolute path of one site's `content/_data/site.json`. */
+export declare function siteDataPath(contentDir: string): string;
+/**
+ * Rewrite `content/_data/site.json` from the settings.
+ *
+ * Written to a temporary file in the same directory and renamed over the old
+ * one, so a reader — an Eleventy build, or the CMS's own site data source —
+ * sees either the whole old file or the whole new one and never a half-written
+ * one.
+ */
+export declare function writeSiteJson(options: {
+    contentDir: string;
+    settings: SiteSettings;
+}): Promise<void>;
+/**
+ * Fill an empty settings table from `content/_data/site.json`, so a site that
+ * existed before this screen did — or one `geekity init` just wrote — keeps
+ * the values it already had.
+ *
+ * Runs once, on the boot that finds the table empty. After that SQLite is the
+ * source and the file is the mirror, so a later hand edit of the file no
+ * longer wins.
+ */
+export declare function seedSiteSettings(options: {
+    store: AdminStore;
+    config: Pick<ResolvedConfig, 'contentDir' | 'baseUrl' | 'baseUrlSource'>;
+}): SiteSettings;
+/**
+ * The base URL actually in effect, and why.
+ *
+ * A base URL is a deployment fact before it is a preference: it decides the
+ * absolute URLs in the feeds, the ActivityPub ids, and whether the session
+ * cookie is `Secure`. So `GEEKITY_BASE_URL` and a `baseUrl` in the config file
+ * both win over the stored setting, and the settings form says so rather than
+ * offering a field that would quietly do nothing.
+ */
+export declare function effectiveBaseUrl(config: Pick<ResolvedConfig, 'baseUrl' | 'baseUrlSource'>, settings: SiteSettings): string;
+/** What is wrong with a submitted settings form, one message per field. */
+export declare function settingsProblems(form: SettingsForm): SettingsProblems;
+/**
+ * A validated form as settings. Only call it on a form
+ * {@link settingsProblems} found nothing wrong with.
+ *
+ * The avatar is carried in rather than read off the form, because it is not on
+ * it: the image is uploaded and removed through {@link AVATAR_PATH}, and a
+ * save of the other fields keeps whatever is stored.
+ */
+export declare function settingsFromForm(form: SettingsForm, avatar?: string): SiteSettings;
+/** The settings as the form shows them. */
+export declare function formFromSettings(settings: SiteSettings): SettingsForm;
+/** What {@link mountSettings} needs from the admin around it. */
+export interface MountSettingsOptions {
+    /** The admin's renderer, which injects the chrome, the CSRF token and the flash. */
+    render: AdminRender;
+}
+/**
+ * Register the settings screen.
+ *
+ * A save writes SQLite and `content/_data/site.json` in that order, so the
+ * store — which is what the theme reads — is never behind the file. A form the
+ * validator has anything to say about is a 400 that writes neither.
+ */
+export declare function mountSettings(app: Hono<GeekityEnv>, options: MountSettingsOptions): void;
+/**
+ * Whether a save moved something the ActivityPub actor carries, which is what
+ * decides whether the followers are told (doc-4: the profile fields come from
+ * the settings). The rest — the time zone, the page size — is the site's own
+ * business and nobody else's.
+ *
+ * The base URL is not here either, though the profile is built on it: it is
+ * settled at boot ({@link effectiveBaseUrl}), so an actor built the moment it
+ * is saved would carry the old one and say nothing new.
+ */
+export declare function profileChanged(before: SiteSettings, after: SiteSettings): boolean;
+//# sourceMappingURL=settings.d.ts.map

package/dist/admin/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/admin/settings.ts"],"names":[],"mappings":"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"}

package/dist/admin/settings.js

@@ -0,0 +1,470 @@
+import { readFileSync } from 'node:fs';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { SITE_DATA_FILE } from '../web/context.js';
+import { flash } from './flash.js';
+import { ADMIN_PREFIX } from './session.js';
+import { ADMIN_TEMPLATES } from './templates.js';
+import { refusedUpload, storeUpload } from './uploads.js';
+/** Where the settings screen lives. */
+export const SETTINGS_PATH = `${ADMIN_PREFIX}/settings`;
+/** Where the avatar's upload form and its Remove button post. */
+export const AVATAR_PATH = `${SETTINGS_PATH}/avatar`;
+/** The fields those two forms submit. */
+export const AVATAR_FIELDS = { file: 'avatar', action: 'action' };
+/** The {@link AVATAR_FIELDS.action} that takes the avatar down again. */
+export const AVATAR_REMOVE = 'remove';
+/**
+ * The ActivityPub actor types doc-4 allows a site to be.
+ *
+ * `Person` is first because it is the default: some clients hide `Service`
+ * actors from timelines, which is the wrong thing for a personal blog.
+ */
+export const ACTOR_TYPES = [
+    'Person',
+    'Organization',
+    'Service',
+    'Group',
+    'Application',
+];
+/**
+ * What an actor handle may be made of. Tighter than a username: the handle
+ * becomes the local part of `@handle@host` in WebFinger and in every mention
+ * somebody types, so it holds no punctuation that would need escaping there.
+ */
+export const ACTOR_HANDLE_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+/**
+ * What a site is worth before anybody has said otherwise.
+ *
+ * `baseUrl` is empty rather than a guess: only the resolved config knows what
+ * port the site is on, so the fallback is applied where the config is in hand.
+ */
+export const DEFAULT_SITE_SETTINGS = {
+    title: 'Geekity',
+    tagline: '',
+    baseUrl: '',
+    timezone: 'UTC',
+    postsPerPage: 10,
+    author: '',
+    actorHandle: 'blog',
+    actorType: 'Person',
+    avatar: '',
+};
+/** The form field each setting is submitted under. */
+export const SETTINGS_FIELDS = {
+    title: 'title',
+    tagline: 'tagline',
+    baseUrl: 'base_url',
+    timezone: 'timezone',
+    postsPerPage: 'posts_per_page',
+    author: 'author',
+    actorHandle: 'actor_handle',
+    actorType: 'actor_type',
+};
+/** The stored settings, with every default filled in. */
+export function readSiteSettings(store) {
+    const stored = store.allSettings();
+    const postsPerPage = Number(stored['postsPerPage']);
+    return {
+        title: stored['title'] ?? DEFAULT_SITE_SETTINGS.title,
+        tagline: stored['tagline'] ?? DEFAULT_SITE_SETTINGS.tagline,
+        baseUrl: stored['baseUrl'] ?? DEFAULT_SITE_SETTINGS.baseUrl,
+        timezone: stored['timezone'] ?? DEFAULT_SITE_SETTINGS.timezone,
+        postsPerPage: Number.isInteger(postsPerPage) && postsPerPage > 0
+            ? postsPerPage
+            : DEFAULT_SITE_SETTINGS.postsPerPage,
+        author: stored['author'] ?? DEFAULT_SITE_SETTINGS.author,
+        actorHandle: stored['actorHandle'] ?? DEFAULT_SITE_SETTINGS.actorHandle,
+        actorType: ACTOR_TYPES.includes(stored['actorType'] ?? '')
+            ? stored['actorType']
+            : DEFAULT_SITE_SETTINGS.actorType,
+        avatar: stored['avatar'] ?? DEFAULT_SITE_SETTINGS.avatar,
+    };
+}
+/** Write a whole settings object back to the store. */
+export function writeSiteSettings(store, settings) {
+    store.setSettings({
+        title: settings.title,
+        tagline: settings.tagline,
+        baseUrl: settings.baseUrl,
+        timezone: settings.timezone,
+        postsPerPage: String(settings.postsPerPage),
+        author: settings.author,
+        actorHandle: settings.actorHandle,
+        actorType: settings.actorType,
+        avatar: settings.avatar,
+    });
+}
+/**
+ * The settings as the `site` global, for the theme and for the JSON mirror.
+ *
+ * Empty strings are left out rather than written as empty values, so a key a
+ * site keeps in `site.json` by hand and leaves blank in the form is overlaid
+ * rather than blanked.
+ */
+export function settingsSiteData(settings) {
+    return {
+        ...(settings.title === '' ? {} : { title: settings.title }),
+        ...(settings.tagline === '' ? {} : { tagline: settings.tagline }),
+        ...(settings.baseUrl === '' ? {} : { url: settings.baseUrl }),
+        ...(settings.author === '' ? {} : { author: settings.author }),
+        ...(settings.timezone === '' ? {} : { timezone: settings.timezone }),
+        ...(settings.avatar === '' ? {} : { avatar: settings.avatar }),
+        postsPerPage: settings.postsPerPage,
+    };
+}
+/**
+ * `content/_data/site.json` as it should read for these settings.
+ *
+ * Every key the form manages is written whether or not it has a value, so the
+ * file's shape is stable and an Eleventy template may reference `site.author`
+ * without guarding it. Every other key the file already had is kept: a site
+ * may put anything in there and reach it from its templates, and the settings
+ * form is not going to be the thing that throws it away.
+ */
+export function siteJsonFor(settings, existing = {}) {
+    return {
+        ...existing,
+        title: settings.title,
+        tagline: settings.tagline,
+        url: settings.baseUrl,
+        author: settings.author,
+        postsPerPage: settings.postsPerPage,
+        timezone: settings.timezone,
+        avatar: settings.avatar,
+    };
+}
+/** The absolute path of one site's `content/_data/site.json`. */
+export function siteDataPath(contentDir) {
+    return path.join(contentDir, ...SITE_DATA_FILE.split('/'));
+}
+/**
+ * Rewrite `content/_data/site.json` from the settings.
+ *
+ * Written to a temporary file in the same directory and renamed over the old
+ * one, so a reader — an Eleventy build, or the CMS's own site data source —
+ * sees either the whole old file or the whole new one and never a half-written
+ * one.
+ */
+export async function writeSiteJson(options) {
+    const file = siteDataPath(options.contentDir);
+    await mkdir(path.dirname(file), { recursive: true });
+    let existing = {};
+    try {
+        existing = parseSiteJson(await readFile(file, 'utf8'));
+    }
+    catch {
+        // No file yet, or one that will not parse. Either way the settings are
+        // what the file is about to say.
+    }
+    const temporary = `${file}.${process.pid.toString(36)}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(siteJsonFor(options.settings, existing), null, 2)}\n`, 'utf8');
+    await rename(temporary, file);
+}
+/**
+ * Fill an empty settings table from `content/_data/site.json`, so a site that
+ * existed before this screen did — or one `geekity init` just wrote — keeps
+ * the values it already had.
+ *
+ * Runs once, on the boot that finds the table empty. After that SQLite is the
+ * source and the file is the mirror, so a later hand edit of the file no
+ * longer wins.
+ */
+export function seedSiteSettings(options) {
+    const { store, config } = options;
+    if (store.countSettings() > 0)
+        return readSiteSettings(store);
+    const file = readSiteJsonSync(siteDataPath(config.contentDir));
+    const postsPerPage = Number(file['postsPerPage']);
+    const seeded = {
+        ...DEFAULT_SITE_SETTINGS,
+        ...(typeof file['title'] === 'string' && file['title'] !== '' ? { title: file['title'] } : {}),
+        ...(typeof file['tagline'] === 'string' ? { tagline: file['tagline'] } : {}),
+        ...(typeof file['author'] === 'string' ? { author: file['author'] } : {}),
+        ...(typeof file['timezone'] === 'string' && file['timezone'] !== ''
+            ? { timezone: file['timezone'] }
+            : {}),
+        ...(typeof file['avatar'] === 'string' ? { avatar: file['avatar'] } : {}),
+        ...(Number.isInteger(postsPerPage) && postsPerPage > 0 ? { postsPerPage } : {}),
+        // The file's `url` only becomes the setting when the deployment has not
+        // named one; otherwise the setting records what is actually in effect.
+        baseUrl: config.baseUrlSource === 'default' && typeof file['url'] === 'string' && file['url'] !== ''
+            ? file['url']
+            : config.baseUrl,
+    };
+    writeSiteSettings(store, seeded);
+    return seeded;
+}
+/**
+ * The base URL actually in effect, and why.
+ *
+ * A base URL is a deployment fact before it is a preference: it decides the
+ * absolute URLs in the feeds, the ActivityPub ids, and whether the session
+ * cookie is `Secure`. So `GEEKITY_BASE_URL` and a `baseUrl` in the config file
+ * both win over the stored setting, and the settings form says so rather than
+ * offering a field that would quietly do nothing.
+ */
+export function effectiveBaseUrl(config, settings) {
+    if (config.baseUrlSource !== 'default')
+        return config.baseUrl;
+    return settings.baseUrl === '' ? config.baseUrl : settings.baseUrl;
+}
+/** What is wrong with a submitted settings form, one message per field. */
+export function settingsProblems(form) {
+    const problems = {};
+    if (form.title.trim() === '')
+        problems.title = 'The site needs a title.';
+    const url = normalizeBaseUrl(form.baseUrl);
+    if (url === undefined) {
+        problems.baseUrl = 'The base URL has to be an absolute http:// or https:// URL.';
+    }
+    const perPage = Number(form.postsPerPage);
+    if (!Number.isInteger(perPage) || perPage < 1) {
+        problems.postsPerPage = 'Posts per page has to be a whole number of one or more.';
+    }
+    if (!isValidTimezone(form.timezone)) {
+        problems.timezone = 'That is not an IANA time zone name, such as Europe/London.';
+    }
+    if (!ACTOR_HANDLE_PATTERN.test(form.actorHandle)) {
+        problems.actorHandle =
+            'An actor handle is 1 to 64 letters, digits, dashes or underscores, with no @ and no dots.';
+    }
+    if (!ACTOR_TYPES.includes(form.actorType)) {
+        problems.actorType = `An actor type is one of ${ACTOR_TYPES.join(', ')}.`;
+    }
+    return problems;
+}
+/**
+ * A validated form as settings. Only call it on a form
+ * {@link settingsProblems} found nothing wrong with.
+ *
+ * The avatar is carried in rather than read off the form, because it is not on
+ * it: the image is uploaded and removed through {@link AVATAR_PATH}, and a
+ * save of the other fields keeps whatever is stored.
+ */
+export function settingsFromForm(form, avatar = DEFAULT_SITE_SETTINGS.avatar) {
+    return {
+        avatar,
+        title: form.title.trim(),
+        tagline: form.tagline.trim(),
+        baseUrl: normalizeBaseUrl(form.baseUrl) ?? '',
+        timezone: form.timezone.trim(),
+        postsPerPage: Number(form.postsPerPage),
+        author: form.author.trim(),
+        actorHandle: form.actorHandle.trim(),
+        actorType: form.actorType,
+    };
+}
+/** The settings as the form shows them. */
+export function formFromSettings(settings) {
+    return {
+        title: settings.title,
+        tagline: settings.tagline,
+        baseUrl: settings.baseUrl,
+        timezone: settings.timezone,
+        postsPerPage: String(settings.postsPerPage),
+        author: settings.author,
+        actorHandle: settings.actorHandle,
+        actorType: settings.actorType,
+    };
+}
+/**
+ * Register the settings screen.
+ *
+ * A save writes SQLite and `content/_data/site.json` in that order, so the
+ * store — which is what the theme reads — is never behind the file. A form the
+ * validator has anything to say about is a 400 that writes neither.
+ */
+export function mountSettings(app, options) {
+    const { render } = options;
+    app.get(SETTINGS_PATH, (c) => render(c, ADMIN_TEMPLATES.settings, screen(c.var.config, readSiteSettings(c.var.admin))));
+    app.post(SETTINGS_PATH, async (c) => {
+        const body = await c.req.parseBody();
+        const stored = readSiteSettings(c.var.admin);
+        const submitted = {
+            title: field(body[SETTINGS_FIELDS.title]),
+            tagline: field(body[SETTINGS_FIELDS.tagline]),
+            // A field the form rendered read-only is not submitted, so an overridden
+            // base URL keeps the value it had rather than being cleared by a save.
+            baseUrl: c.var.config.baseUrlSource === 'default'
+                ? field(body[SETTINGS_FIELDS.baseUrl])
+                : stored.baseUrl === ''
+                    ? c.var.config.baseUrl
+                    : stored.baseUrl,
+            timezone: field(body[SETTINGS_FIELDS.timezone]),
+            postsPerPage: field(body[SETTINGS_FIELDS.postsPerPage]),
+            author: field(body[SETTINGS_FIELDS.author]),
+            actorHandle: field(body[SETTINGS_FIELDS.actorHandle]),
+            actorType: field(body[SETTINGS_FIELDS.actorType]),
+        };
+        const problems = settingsProblems(submitted);
+        if (Object.keys(problems).length > 0) {
+            c.status(400);
+            return render(c, ADMIN_TEMPLATES.settings, {
+                ...screen(c.var.config, stored),
+                form: submitted,
+                problems,
+            });
+        }
+        const settings = settingsFromForm(submitted, stored.avatar);
+        await store(c, settings);
+        // The name, the summary and the handle are the actor's profile as much as
+        // the avatar is, and a follower's copy of it is only as fresh as the last
+        // thing it was told.
+        const report = profileChanged(stored, settings)
+            ? await c.var.delivery.updateActor()
+            : undefined;
+        flash(c, 'notice', `Settings saved.${toldFollowers(report)}`);
+        return c.redirect(SETTINGS_PATH, 303);
+    });
+    /**
+     * The avatar's own endpoint: one multipart form uploads an image, and a
+     * second, plain one takes it down again.
+     *
+     * It is separate from the settings form because a file cannot travel in a
+     * urlencoded body, and because the two should not share a fate: a rejected
+     * image must not lose an edit to the title, and a rejected title must not
+     * lose the avatar. A refusal is a flash and a redirect, so what is stored is
+     * exactly what it was and the screen says why.
+     */
+    app.post(AVATAR_PATH, async (c) => {
+        const body = await c.req.parseBody();
+        const stored = readSiteSettings(c.var.admin);
+        if (field(body[AVATAR_FIELDS.action]) === AVATAR_REMOVE) {
+            if (stored.avatar === '') {
+                flash(c, 'notice', 'The site has no avatar.');
+                return c.redirect(SETTINGS_PATH, 303);
+            }
+            await store(c, { ...stored, avatar: '' });
+            const removal = await c.var.delivery.updateActor();
+            flash(c, 'notice', `Avatar removed.${toldFollowers(removal)}`);
+            return c.redirect(SETTINGS_PATH, 303);
+        }
+        const outcome = await storeUpload(body[AVATAR_FIELDS.file], c.var.config, {
+            imagesOnly: true,
+        });
+        if (refusedUpload(outcome)) {
+            flash(c, 'error', `${outcome.error} The avatar is unchanged.`);
+            return c.redirect(SETTINGS_PATH, 303);
+        }
+        await store(c, { ...stored, avatar: outcome.url });
+        const report = await c.var.delivery.updateActor();
+        flash(c, 'notice', `Avatar saved.${toldFollowers(report)}`);
+        return c.redirect(SETTINGS_PATH, 303);
+    });
+    /**
+     * Write settings to SQLite and then to `content/_data/site.json`, in that
+     * order, so the store — which is what the theme reads — is never behind the
+     * file.
+     */
+    async function store(c, settings) {
+        writeSiteSettings(c.var.admin, settings);
+        await writeSiteJson({ contentDir: c.var.config.contentDir, settings });
+    }
+}
+/**
+ * Whether a save moved something the ActivityPub actor carries, which is what
+ * decides whether the followers are told (doc-4: the profile fields come from
+ * the settings). The rest — the time zone, the page size — is the site's own
+ * business and nobody else's.
+ *
+ * The base URL is not here either, though the profile is built on it: it is
+ * settled at boot ({@link effectiveBaseUrl}), so an actor built the moment it
+ * is saved would carry the old one and say nothing new.
+ */
+export function profileChanged(before, after) {
+    return (before.title !== after.title ||
+        before.tagline !== after.tagline ||
+        before.actorHandle !== after.actorHandle ||
+        before.actorType !== after.actorType ||
+        before.avatar !== after.avatar);
+}
+/**
+ * The sentence a flash adds about the followers, when there were any: a save
+ * of the profile is also an announcement, and it should say so rather than
+ * leave the admin wondering.
+ */
+function toldFollowers(report) {
+    const total = report?.deliveries.length ?? 0;
+    if (total === 0)
+        return '';
+    return total === 1
+        ? ' One follower has been told.'
+        : ` ${String(total)} followers have been told.`;
+}
+/** Everything the settings template renders, for a given set of settings. */
+function screen(config, settings) {
+    const overridden = config.baseUrlSource !== 'default';
+    return {
+        section: 'settings',
+        settingsUrl: SETTINGS_PATH,
+        fields: SETTINGS_FIELDS,
+        actorTypes: ACTOR_TYPES,
+        avatar: settings.avatar,
+        avatarUrl: AVATAR_PATH,
+        avatarFields: AVATAR_FIELDS,
+        avatarRemove: AVATAR_REMOVE,
+        form: formFromSettings(settings),
+        problems: {},
+        baseUrlInEffect: effectiveBaseUrl(config, settings),
+        baseUrlOverridden: overridden,
+        baseUrlSource: config.baseUrlSource,
+        baseUrlNote: overridden
+            ? config.baseUrlSource === 'environment'
+                ? 'GEEKITY_BASE_URL is set, so it is the base URL in effect and this field is not editable here.'
+                : 'The config file sets baseUrl, so it is the base URL in effect and this field is not editable here.'
+            : 'Absolute URLs, the feeds and the session cookie pick this up when the site next starts.',
+    };
+}
+/** A form field as a string. A file upload, or a missing field, is the empty one. */
+function field(value) {
+    return typeof value === 'string' ? value : '';
+}
+/**
+ * A base URL, normalised the way `resolveConfig` normalises the configured
+ * one, or `undefined` when it is not an absolute http(s) URL.
+ */
+function normalizeBaseUrl(value) {
+    const trimmed = value.trim();
+    if (trimmed === '')
+        return undefined;
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+        return undefined;
+    const pathname = parsed.pathname.endsWith('/') ? parsed.pathname.slice(0, -1) : parsed.pathname;
+    return parsed.origin + pathname;
+}
+/** Whether `Intl` knows the zone. An empty name is not a zone. */
+function isValidTimezone(value) {
+    const zone = value.trim();
+    if (zone === '')
+        return false;
+    try {
+        new Intl.DateTimeFormat(undefined, { timeZone: zone });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readSiteJsonSync(file) {
+    try {
+        return parseSiteJson(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+function parseSiteJson(source) {
+    const parsed = JSON.parse(source);
+    return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+        ? parsed
+        : {};
+}
+//# sourceMappingURL=settings.js.map