@gjsify/site 0.64.10 → 0.64.12-next.279

package/lib/site-data/blog.js

@@ -0,0 +1,226 @@
+import { existsSync } from 'node:fs';
+import { readFile, readdir } from 'node:fs/promises';
+import { join, relative, sep } from 'node:path';
+import { parseFrontmatter } from './frontmatter.js';
+/** `YYYY-MM-DD` or an ISO 8601 date-time; anything else is a typo the build should name. */
+function validateDate(date, file, key) {
+    const dateOnly = /^\d{4}-\d{2}-\d{2}$/.test(date);
+    const dateTime = /^\d{4}-\d{2}-\d{2}T/.test(date);
+    if ((!dateOnly && !dateTime) || Number.isNaN(new Date(dateOnly ? `${date}T00:00:00Z` : date).getTime())) {
+        throw new Error(`${file}: ${key} "${date}" is not YYYY-MM-DD or an ISO 8601 date-time`);
+    }
+}
+function isValidSlug(slug) {
+    return /^[a-z0-9][a-z0-9-]*$/.test(slug);
+}
+async function walkDir(dir, result) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            // Skip dotdirs
+            if (entry.name.startsWith('.')) {
+                continue;
+            }
+            await walkDir(fullPath, result);
+        }
+        else if (entry.isFile()) {
+            if (entry.name.startsWith('.')) {
+                continue;
+            }
+            result.push(fullPath);
+        }
+    }
+}
+/** Every post under `dir` (recursive), newest first (ties: slug ascending, then lang). */
+export async function loadBlogPosts(options) {
+    const { dir, languages, drafts } = options;
+    if (!existsSync(dir)) {
+        throw new Error(`blog.posts: ${dir} does not exist`);
+    }
+    const allFiles = [];
+    await walkDir(dir, allFiles);
+    const posts = [];
+    const seen = new Map(); // key slug+lang -> file
+    for (const file of allFiles) {
+        const basename = file.split(sep).pop() || file;
+        // skip README.md case-insensitively
+        if (basename.toLowerCase() === 'readme.md') {
+            continue;
+        }
+        if (!basename.endsWith('.md')) {
+            continue;
+        }
+        if (basename.startsWith('.')) {
+            continue;
+        }
+        const content = await readFile(file, 'utf-8');
+        const parsed = parseFrontmatter(content, file);
+        // Determine slug and lang
+        let slug;
+        let lang;
+        // Try filename pattern <slug>.<lang>.md
+        const match = basename.match(/^(.+)\.([^.]+)\.md$/);
+        if (match) {
+            const maybeSlug = match[1];
+            const maybeLang = match[2];
+            if (languages.includes(maybeLang)) {
+                slug = maybeSlug;
+                lang = maybeLang;
+            }
+        }
+        // frontmatter overrides
+        if (parsed.data.slug !== undefined) {
+            if (typeof parsed.data.slug === 'string') {
+                slug = parsed.data.slug;
+            }
+            else {
+                throw new Error(`${file}: slug must be a string`);
+            }
+        }
+        if (parsed.data.lang !== undefined) {
+            if (typeof parsed.data.lang === 'string') {
+                lang = parsed.data.lang;
+            }
+            else {
+                throw new Error(`${file}: lang must be a string`);
+            }
+        }
+        if (lang === undefined || slug === undefined) {
+            throw new Error(`${file}: no language — name the file <slug>.<lang>.md or set "lang" in the frontmatter`);
+        }
+        if (!languages.includes(lang)) {
+            throw new Error(`${file}: lang ${lang} not in allowed list [${languages.join(', ')}]`);
+        }
+        if (!isValidSlug(slug)) {
+            throw new Error(`${file}: invalid slug ${slug}`);
+        }
+        // Check duplicates
+        const key = `${slug}\u0000${lang}`;
+        if (seen.has(key)) {
+            throw new Error(`${file}: duplicate slug+lang with ${seen.get(key)}`);
+        }
+        seen.set(key, file);
+        // Check unknown frontmatter keys
+        const allowedKeys = new Set(['slug', 'lang', 'title', 'date', 'updated', 'summary', 'tags', 'draft']);
+        for (const k of Object.keys(parsed.data)) {
+            if (!allowedKeys.has(k)) {
+                throw new Error(`${file}: unknown frontmatter key ${k}`);
+            }
+        }
+        // Required
+        if (typeof parsed.data.title !== 'string') {
+            throw new Error(`${file}: title must be a string`);
+        }
+        if (typeof parsed.data.date !== 'string') {
+            throw new Error(`${file}: date must be a string`);
+        }
+        validateDate(parsed.data.date, file, 'date');
+        if (parsed.data.updated !== undefined) {
+            if (typeof parsed.data.updated !== 'string') {
+                throw new Error(`${file}: updated must be a string`);
+            }
+            validateDate(parsed.data.updated, file, 'updated');
+        }
+        if (parsed.data.summary !== undefined && typeof parsed.data.summary !== 'string') {
+            throw new Error(`${file}: summary must be a string`);
+        }
+        let tags = [];
+        if (parsed.data.tags !== undefined) {
+            if (typeof parsed.data.tags === 'string') {
+                tags = [parsed.data.tags];
+            }
+            else if (Array.isArray(parsed.data.tags)) {
+                tags = parsed.data.tags.map((t) => String(t));
+            }
+            else {
+                throw new Error(`${file}: tags must be string[]`);
+            }
+        }
+        let draft = false;
+        if (parsed.data.draft !== undefined) {
+            if (typeof parsed.data.draft === 'boolean') {
+                draft = parsed.data.draft;
+            }
+            else {
+                throw new Error(`${file}: draft must be boolean`);
+            }
+        }
+        if (draft && !drafts) {
+            continue;
+        }
+        posts.push({
+            slug,
+            lang,
+            title: parsed.data.title,
+            date: parsed.data.date,
+            updated: parsed.data.updated,
+            summary: parsed.data.summary,
+            tags,
+            draft,
+            body: parsed.body,
+            file,
+        });
+    }
+    // newest first (ties: slug ascending, then lang)
+    posts.sort((a, b) => {
+        const ta = postTime(a.date);
+        const tb = postTime(b.date);
+        if (tb !== ta) {
+            return tb - ta;
+        }
+        if (a.slug !== b.slug) {
+            return a.slug < b.slug ? -1 : 1;
+        }
+        if (a.lang !== b.lang) {
+            return a.lang < b.lang ? -1 : 1;
+        }
+        return 0;
+    });
+    return posts;
+}
+/** Posts with the same slug in the other languages. */
+export function translationsOf(posts, post) {
+    return posts.filter((p) => p.slug === post.slug && p.lang !== post.lang);
+}
+/** Paths relative to dir (POSIX separators) of every non-.md file under dir, recursive, sorted. Skips dotfiles/dot-dirs. */
+export async function blogAssetFiles(dir) {
+    const allFiles = [];
+    await walkDir(dir, allFiles);
+    const result = [];
+    for (const file of allFiles) {
+        const basename = file.split(sep).pop() || file;
+        if (basename.startsWith('.')) {
+            continue;
+        }
+        if (basename.endsWith('.md')) {
+            continue;
+        }
+        const rel = relative(dir, file).split(sep).join('/');
+        result.push(rel);
+    }
+    result.sort();
+    return result;
+}
+/** URL-safe tag slug: lowercase, NFKD with diacritics removed, runs of non [a-z0-9] → '-', trimmed of '-'. Throws if the result is empty. */
+export function tagSlug(tag) {
+    // NFKD normalization
+    const normalized = tag.normalize('NFKD');
+    // Remove diacritics
+    const withoutDiacritics = normalized.replace(/[\u0300-\u036f]/g, '');
+    const lower = withoutDiacritics.toLowerCase();
+    const slug = lower.replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+    if (slug === '') {
+        throw new Error('empty tag slug');
+    }
+    return slug;
+}
+/** Milliseconds since epoch for sorting/feeds; a date-only value means 00:00 UTC. */
+export function postTime(date) {
+    if (/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+        const d = new Date(date + 'T00:00:00Z');
+        return d.getTime();
+    }
+    const d = new Date(date);
+    return d.getTime();
+}

package/lib/site-data/config.d.ts

@@ -1,4 +1,4 @@
-import type { SiteConfig } from './types.js';
+import type { AnySiteConfig, SiteConfig } from './types.js';
 /** The slice of the root package.json the site reads. Everything is optional until validated. */
 export interface RootManifest {
     version?: string;
@@ -19,7 +19,12 @@ export interface RootManifest {
 }
 /** Root-relative directory URL: `/x/` with a leading and trailing slash. */
 export declare function normalizeBase(base: string): string;
-/** Validates `gjsify.site` and applies defaults; the error names the offending key. */
+/**
+ * Validates `gjsify.site` of either kind and applies defaults; the error names the offending key.
+ * The kind is the presence of `metainfo` (an app) or `developer` (a person) — exactly one of them.
+ */
+export declare function parseAnySiteConfig(manifest: RootManifest): AnySiteConfig;
+/** Validates an app's `gjsify.site` and applies defaults; the error names the offending key. */
 export declare function parseSiteConfig(manifest: RootManifest): SiteConfig;
 /** The `kind` labels the support page knows by name; the page catalogues translate them. */
 export declare const SUPPORT_KIND_LABELS: readonly ["GitHub Sponsors", "Liberapay", "PayPal"];

package/lib/site-data/config.js

@@ -60,14 +60,13 @@ function httpUrl(value, where) {
     return value;
 }
 /** Strings are site addresses to fetch `app.json` from; objects are inline entries for apps without one. */
-function parseRelatedApps(raw) {
-    const value = raw.relatedApps;
+function parseRelatedApps(value, key) {
     if (value === undefined)
         return [];
     if (!Array.isArray(value))
-        throw new Error('gjsify.site.relatedApps must be a list');
+        throw new Error(`${key} must be a list`);
     return value.map((entry, index) => {
-        const where = `gjsify.site.relatedApps[${index}]`;
+        const where = `${key}[${index}]`;
         if (typeof entry === 'string')
             return { url: withSlash(httpUrl(entry, where)) };
         if (!isRecord(entry))
@@ -207,11 +206,60 @@ function parseReleaseAssets(raw) {
 export function normalizeBase(base) {
     return `/${base.replace(/^\/+|\/+$/g, '')}/`.replace(/^\/\/$/, '/');
 }
-/** Validates `gjsify.site` and applies defaults; the error names the offending key. */
-export function parseSiteConfig(manifest) {
-    const raw = manifest.gjsify?.site;
-    if (!isRecord(raw))
-        throw new Error('The root package.json has no "gjsify.site" object');
+function parseBlog(raw) {
+    const value = raw.blog;
+    if (value === undefined)
+        return undefined;
+    if (!isRecord(value))
+        throw new Error('gjsify.site.blog must be an object');
+    return { posts: stringField(value, 'posts', 'gjsify.site.blog') };
+}
+const HEX_COLOR = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
+function parseColor(value, where) {
+    const hex = (entry, key) => {
+        if (typeof entry !== 'string' || !HEX_COLOR.test(entry))
+            throw new Error(`${key} must be a hex colour like #3584e4`);
+        return entry;
+    };
+    if (typeof value === 'string')
+        return { light: hex(value, where), dark: value };
+    if (!isRecord(value))
+        throw new Error(`${where} must be a hex colour or { "light", "dark" }`);
+    return { light: hex(value.light, `${where}.light`), dark: hex(value.dark, `${where}.dark`) };
+}
+function parseTheme(raw) {
+    const value = raw.theme;
+    if (value === undefined)
+        return { imageRendering: 'auto' };
+    if (!isRecord(value))
+        throw new Error('gjsify.site.theme must be an object');
+    const imageRendering = value.imageRendering ?? 'auto';
+    if (imageRendering !== 'auto' && imageRendering !== 'pixelated') {
+        throw new Error('gjsify.site.theme.imageRendering must be "auto" or "pixelated"');
+    }
+    const displayFont = value.displayFont === undefined ? undefined : stringField(value, 'displayFont', 'gjsify.site.theme');
+    if (displayFont !== undefined && !displayFont.endsWith('.woff2'))
+        throw new Error('gjsify.site.theme.displayFont must be a .woff2 file');
+    return {
+        accent: value.accent === undefined ? undefined : parseColor(value.accent, 'gjsify.site.theme.accent'),
+        displayFont,
+        imageRendering,
+    };
+}
+/** One file per configured language, so no page of the CV silently falls back to another language. */
+function parseDeveloper(value, languages) {
+    if (!isRecord(value))
+        throw new Error('gjsify.site.developer must be an object');
+    const resume = value.resume;
+    if (!isRecord(resume)) {
+        throw new Error('gjsify.site.developer.resume must be an object mapping a language to a JSON Resume file');
+    }
+    return {
+        resume: Object.fromEntries(languages.map((lang) => [lang, stringField(resume, lang, 'gjsify.site.developer.resume')])),
+        apps: parseRelatedApps(value.apps, 'gjsify.site.developer.apps'),
+    };
+}
+function parseCommon(raw, base) {
     const languages = raw.languages ?? ['en'];
     if (!Array.isArray(languages) || languages.length === 0 || !languages.every((entry) => typeof entry === 'string')) {
         throw new Error('gjsify.site.languages must be a non-empty list of language codes');
@@ -219,24 +267,14 @@ export function parseSiteConfig(manifest) {
     const defaultLanguage = optionalString(raw, 'defaultLanguage') ?? languages[0];
     if (!languages.includes(defaultLanguage))
         throw new Error(`gjsify.site.defaultLanguage "${defaultLanguage}" is not in languages`);
-    const url = requireString(raw, 'url');
-    const components = parseComponents(raw);
+    const url = withSlash(requireString(raw, 'url'));
     return {
-        metainfo: requireString(raw, 'metainfo'),
-        base: normalizeBase(requireString(raw, 'base')),
-        url: withSlash(url),
+        base: normalizeBase(base ?? requireString(raw, 'base')),
+        url,
         languages: languages,
         defaultLanguage,
         sourceLanguage: optionalString(raw, 'sourceLanguage') ?? 'en',
-        repository: requireString(raw, 'repository'),
-        flathub: optionalString(raw, 'flathub'),
-        webApp: optionalString(raw, 'webApp'),
-        translations: optionalString(raw, 'translations'),
         pageTranslations: optionalString(raw, 'pageTranslations'),
-        icon: optionalString(raw, 'icon'),
-        components,
-        downloads: parseDownloads(raw, components),
-        releaseAssets: parseReleaseAssets(raw),
         support: objectList(raw, 'support').map((entry, index) => parseSupport(entry, `gjsify.site.support[${index}]`)),
         privacy: parsePrivacy(raw, languages),
         legalNotice: parseLegalNotice(raw, languages),
@@ -244,7 +282,64 @@ export function parseSiteConfig(manifest) {
             label: stringField(entry, 'label', `gjsify.site.legal[${index}]`),
             url: stringField(entry, 'url', `gjsify.site.legal[${index}]`),
         })),
-        relatedApps: parseRelatedApps(raw),
+        blog: parseBlog(raw),
+        theme: parseTheme(raw),
+    };
+}
+function siteBlock(manifest) {
+    const raw = manifest.gjsify?.site;
+    if (!isRecord(raw))
+        throw new Error('The root package.json has no "gjsify.site" object');
+    return raw;
+}
+/**
+ * Validates `gjsify.site` of either kind and applies defaults; the error names the offending key.
+ * The kind is the presence of `metainfo` (an app) or `developer` (a person) — exactly one of them.
+ */
+export function parseAnySiteConfig(manifest) {
+    const raw = siteBlock(manifest);
+    const isApp = raw.metainfo !== undefined;
+    const isDeveloper = raw.developer !== undefined;
+    if (isApp && isDeveloper) {
+        throw new Error('gjsify.site has both "metainfo" and "developer"; a site is about one app or one person');
+    }
+    if (!isApp && !isDeveloper) {
+        throw new Error('gjsify.site needs "metainfo" (an app site) or "developer" (a developer site)');
+    }
+    if (isApp)
+        return parseSiteConfig(manifest);
+    // The developer site usually owns the host root, so `base` may be left out there.
+    const common = parseCommon(raw, optionalString(raw, 'base') ?? '/');
+    if (raw.relatedApps !== undefined) {
+        throw new Error('gjsify.site.relatedApps is for app sites; a developer site lists apps in developer.apps');
+    }
+    return {
+        kind: 'developer',
+        ...common,
+        developer: parseDeveloper(raw.developer, common.languages),
+        repository: optionalString(raw, 'repository'),
+    };
+}
+/** Validates an app's `gjsify.site` and applies defaults; the error names the offending key. */
+export function parseSiteConfig(manifest) {
+    const raw = siteBlock(manifest);
+    if (raw.developer !== undefined)
+        throw new Error('gjsify.site describes a developer site, not an app');
+    const common = parseCommon(raw, undefined);
+    const components = parseComponents(raw);
+    return {
+        kind: 'app',
+        ...common,
+        metainfo: requireString(raw, 'metainfo'),
+        repository: requireString(raw, 'repository'),
+        flathub: optionalString(raw, 'flathub'),
+        webApp: optionalString(raw, 'webApp'),
+        translations: optionalString(raw, 'translations'),
+        icon: optionalString(raw, 'icon'),
+        components,
+        downloads: parseDownloads(raw, components),
+        releaseAssets: parseReleaseAssets(raw),
+        relatedApps: parseRelatedApps(raw.relatedApps, 'gjsify.site.relatedApps'),
     };
 }
 /** The `kind` labels the support page knows by name; the page catalogues translate them. */

package/lib/site-data/developer.d.ts

@@ -0,0 +1,16 @@
+import { type RelatedAppsOptions } from './related.js';
+import { type Resume } from './resume.js';
+import type { DeveloperSiteConfig, RelatedApp } from './types.js';
+/** Everything a developer site renders that does not come from the blog. */
+export interface DeveloperData {
+    config: DeveloperSiteConfig;
+    /** One résumé per configured language. */
+    resumes: Record<string, Resume>;
+    /** `developer.apps`, resolved; an app that cannot be had is left out with a warning. */
+    apps: RelatedApp[];
+}
+export interface LoadDeveloperOptions extends Omit<RelatedAppsOptions, 'warn'> {
+    root: string;
+    warn?: (message: string) => void;
+}
+export declare function loadDeveloperData(config: DeveloperSiteConfig, options: LoadDeveloperOptions): Promise<DeveloperData>;

package/lib/site-data/developer.js

@@ -0,0 +1,12 @@
+import { resolve } from 'node:path';
+import { loadAppEntries } from './related.js';
+import { loadResume } from './resume.js';
+export async function loadDeveloperData(config, options) {
+    const entries = await Promise.all(config.languages.map(async (lang) => [lang, await loadResume(resolve(options.root, config.developer.resume[lang]))]));
+    const apps = await loadAppEntries(config.developer.apps, {
+        offline: options.offline,
+        network: options.network,
+        warn: options.warn ?? (() => { }),
+    });
+    return { config, resumes: Object.fromEntries(entries), apps };
+}

package/lib/site-data/frontmatter.d.ts

@@ -0,0 +1,7 @@
+export type FrontmatterValue = string | boolean | string[];
+export interface Frontmatter {
+    data: Record<string, FrontmatterValue>;
+    body: string;
+}
+/** `file` is only used in error messages. Text without a leading `---` line has empty data and the whole text as body. */
+export declare function parseFrontmatter(text: string, file: string): Frontmatter;