cosmolo 0.3.3 → 0.3.4

package/dist/loaders.d.ts

@@ -0,0 +1,105 @@
+import type { Article, ResolvedCosmoloConfig } from './types.js';
+/**
+ * Factory for the article listing page load function.
+ *
+ * @example
+ * // src/routes/+page.server.ts
+ * import { createArticlesLoader } from 'cosmolo';
+ * import config from '../../cosmolo.config';
+ * export const load = createArticlesLoader(config);
+ */
+export declare function createArticlesLoader(config: ResolvedCosmoloConfig): () => {
+    articles: Article[];
+};
+/**
+ * Factory for a single article page load function.
+ * Resolves manual related articles, series prev/next, and git updated date.
+ *
+ * @example
+ * // src/routes/articles/[slug]/+page.server.ts
+ * import { createArticleLoader } from 'cosmolo';
+ * import config from '../../../../cosmolo.config';
+ * export const entries = () => getSlugs(config).map(slug => ({ slug }));
+ * export const load = createArticleLoader(config);
+ */
+export declare function createArticleLoader(config: ResolvedCosmoloConfig, options?: {
+    getUpdatedAt?: (slug: string) => string;
+}): ({ params }: {
+    params: {
+        slug: string;
+    };
+}) => Promise<{
+    article: Article;
+    related: Article[];
+    updatedAt: string;
+    seriesPrev: Article | null;
+    seriesNext: Article | null;
+    seriesTotal: number;
+}>;
+/**
+ * Factory for the category listing page load function.
+ *
+ * @example
+ * // src/routes/categories/[slug]/+page.server.ts
+ * import { createCategoryLoader } from 'cosmolo';
+ * import config from '../../../../cosmolo.config';
+ * export const entries = () => getCategorySlugs(config).map(slug => ({ slug }));
+ * export const load = createCategoryLoader(config);
+ */
+export declare function createCategoryLoader(config: ResolvedCosmoloConfig): ({ params }: {
+    params: {
+        slug: string;
+    };
+}) => {
+    slug: string;
+    label: string;
+    description: string;
+    articles: Article[];
+};
+/**
+ * Factory for the tag listing page load function.
+ *
+ * @example
+ * // src/routes/tags/[tag]/+page.server.ts
+ * import { createTagLoader } from 'cosmolo';
+ * import config from '../../../../cosmolo.config';
+ * export const entries = () => getTags(config).map(tag => ({ tag }));
+ * export const load = createTagLoader(config);
+ */
+export declare function createTagLoader(config: ResolvedCosmoloConfig): ({ params }: {
+    params: {
+        tag: string;
+    };
+}) => {
+    tag: string;
+    articles: Article[];
+};
+/**
+ * Factory for the static page load function.
+ *
+ * @example
+ * // src/routes/(pages)/[slug]/+page.server.ts
+ * import { createPageLoader } from 'cosmolo';
+ * import config from '../../../../cosmolo.config';
+ * export const entries = () => getPageSlugs(config).map(slug => ({ slug }));
+ * export const load = createPageLoader(config);
+ */
+export declare function createPageLoader(config: ResolvedCosmoloConfig): ({ params }: {
+    params: {
+        slug: string;
+    };
+}) => Promise<{
+    page: import("./types.js").Page;
+}>;
+export declare function createArticleEntries(config: ResolvedCosmoloConfig): () => {
+    slug: string;
+}[];
+export declare function createCategoryEntries(config: ResolvedCosmoloConfig): () => {
+    slug: string;
+}[];
+export declare function createTagEntries(config: ResolvedCosmoloConfig): () => {
+    tag: string;
+}[];
+export declare function createPageEntries(config: ResolvedCosmoloConfig): () => {
+    slug: string;
+}[];

package/dist/loaders.js

@@ -0,0 +1,119 @@
+import { getArticle, getArticles, getArticlesByCategory, getArticlesBySeries, getArticlesByTag, getSlugs, getTags } from './articles.js';
+import { getCategorySlugs, getCategoryLabel, getCategoryDescription } from './categories.js';
+import { getPage, getPageSlugs } from './pages.js';
+/**
+ * Factory for the article listing page load function.
+ *
+ * @example
+ * // src/routes/+page.server.ts
+ * import { createArticlesLoader } from 'cosmolo';
+ * import config from '../../cosmolo.config';
+ * export const load = createArticlesLoader(config);
+ */
+export function createArticlesLoader(config) {
+    return () => ({ articles: getArticles(config) });
+}
+/**
+ * Factory for a single article page load function.
+ * Resolves manual related articles, series prev/next, and git updated date.
+ *
+ * @example
+ * // src/routes/articles/[slug]/+page.server.ts
+ * import { createArticleLoader } from 'cosmolo';
+ * import config from '../../../../cosmolo.config';
+ * export const entries = () => getSlugs(config).map(slug => ({ slug }));
+ * export const load = createArticleLoader(config);
+ */
+export function createArticleLoader(config, options = {}) {
+    return async ({ params }) => {
+        const article = await getArticle(config, params.slug);
+        const updatedAt = options.getUpdatedAt?.(params.slug) ?? '';
+        let related;
+        if (article.related.length > 0) {
+            const all = getArticles(config);
+            related = article.related
+                .map((s) => all.find((a) => a.slug === s))
+                .filter((a) => a !== undefined)
+                .slice(0, 4);
+        }
+        else {
+            related = getArticlesByCategory(config, article.category, params.slug).slice(0, 4);
+        }
+        let seriesPrev = null;
+        let seriesNext = null;
+        let seriesTotal = 0;
+        if (article.series) {
+            const seriesArticles = getArticlesBySeries(config, article.series);
+            seriesTotal = seriesArticles.length;
+            const idx = seriesArticles.findIndex((a) => a.slug === params.slug);
+            seriesPrev = idx > 0 ? seriesArticles[idx - 1] : null;
+            seriesNext = idx < seriesArticles.length - 1 ? seriesArticles[idx + 1] : null;
+        }
+        return { article, related, updatedAt, seriesPrev, seriesNext, seriesTotal };
+    };
+}
+/**
+ * Factory for the category listing page load function.
+ *
+ * @example
+ * // src/routes/categories/[slug]/+page.server.ts
+ * import { createCategoryLoader } from 'cosmolo';
+ * import config from '../../../../cosmolo.config';
+ * export const entries = () => getCategorySlugs(config).map(slug => ({ slug }));
+ * export const load = createCategoryLoader(config);
+ */
+export function createCategoryLoader(config) {
+    return ({ params }) => {
+        const { slug } = params;
+        return {
+            slug,
+            label: getCategoryLabel(config, slug),
+            description: getCategoryDescription(config, slug),
+            articles: getArticlesByCategory(config, slug),
+        };
+    };
+}
+/**
+ * Factory for the tag listing page load function.
+ *
+ * @example
+ * // src/routes/tags/[tag]/+page.server.ts
+ * import { createTagLoader } from 'cosmolo';
+ * import config from '../../../../cosmolo.config';
+ * export const entries = () => getTags(config).map(tag => ({ tag }));
+ * export const load = createTagLoader(config);
+ */
+export function createTagLoader(config) {
+    return ({ params }) => ({
+        tag: params.tag,
+        articles: getArticlesByTag(config, params.tag),
+    });
+}
+/**
+ * Factory for the static page load function.
+ *
+ * @example
+ * // src/routes/(pages)/[slug]/+page.server.ts
+ * import { createPageLoader } from 'cosmolo';
+ * import config from '../../../../cosmolo.config';
+ * export const entries = () => getPageSlugs(config).map(slug => ({ slug }));
+ * export const load = createPageLoader(config);
+ */
+export function createPageLoader(config) {
+    return async ({ params }) => ({
+        page: await getPage(config, params.slug),
+    });
+}
+// ─── entries generators ───────────────────────────────────────────────────────
+export function createArticleEntries(config) {
+    return () => getSlugs(config).map((slug) => ({ slug }));
+}
+export function createCategoryEntries(config) {
+    return () => getCategorySlugs(config).map((slug) => ({ slug }));
+}
+export function createTagEntries(config) {
+    return () => getTags(config).map((tag) => ({ tag }));
+}
+export function createPageEntries(config) {
+    return () => getPageSlugs(config).map((slug) => ({ slug }));
+}

package/dist/markdown.d.ts

@@ -0,0 +1,3 @@
+import type { TocEntry } from './types.js';
+export declare function renderMarkdown(content: string): Promise<string>;
+export declare function generateToc(content: string): TocEntry[];

package/dist/markdown.js

@@ -0,0 +1,69 @@
+import { marked } from 'marked';
+function slugifyHeading(text) {
+    return text
+        .toLowerCase()
+        .replace(/<[^>]+>/g, '')
+        .replace(/[^\w\s-]/g, '')
+        .trim()
+        .replace(/\s+/g, '-');
+}
+marked.use({
+    extensions: [
+        {
+            name: 'youtube',
+            level: 'block',
+            start(src) {
+                return src.indexOf('::youtube[');
+            },
+            tokenizer(src) {
+                const match = /^::youtube\[([^\]]+)\]/.exec(src);
+                if (match)
+                    return { type: 'youtube', raw: match[0], videoId: match[1].trim() };
+            },
+            renderer(token) {
+                const { videoId } = token;
+                return `<div class="youtube-embed"><iframe src="https://www.youtube.com/embed/${videoId}" title="YouTube video" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe></div>\n`;
+            },
+        },
+    ],
+});
+marked.use({
+    renderer: {
+        link({ href, title, text }) {
+            const isExternal = /^https?:\/\//.test(href ?? '');
+            const rel = isExternal ? ' target="_blank" rel="noopener noreferrer"' : '';
+            const titleAttr = title ? ` title="${title}"` : '';
+            return `<a href="${href}"${titleAttr}${rel}>${text}</a>`;
+        },
+        heading({ text, depth }) {
+            const id = slugifyHeading(text);
+            return `<h${depth} id="${id}">${text}</h${depth}>\n`;
+        },
+    },
+});
+export async function renderMarkdown(content) {
+    return marked.parse(content);
+}
+export function generateToc(content) {
+    const entries = [];
+    const seenIds = new Map();
+    const headingRegex = /^(#{2,6})\s+(.+?)$/gm;
+    let match;
+    while ((match = headingRegex.exec(content)) !== null) {
+        const level = match[1].length;
+        const rawText = match[2].trim();
+        const plainText = rawText
+            .replace(/\*\*([^*]+)\*\*/g, '$1')
+            .replace(/\*([^*]+)\*/g, '$1')
+            .replace(/__([^_]+)__/g, '$1')
+            .replace(/_([^_]+)_/g, '$1')
+            .replace(/`([^`]+)`/g, '$1')
+            .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+        const baseId = slugifyHeading(plainText);
+        const count = seenIds.get(baseId) ?? 0;
+        const id = count === 0 ? baseId : `${baseId}-${count}`;
+        seenIds.set(baseId, count + 1);
+        entries.push({ level, id, text: plainText });
+    }
+    return entries;
+}

package/dist/pages.d.ts

@@ -0,0 +1,3 @@
+import type { Page, ResolvedCosmoloConfig } from './types.js';
+export declare function getPageSlugs(config: ResolvedCosmoloConfig): string[];
+export declare function getPage(config: ResolvedCosmoloConfig, slug: string): Promise<Page>;

package/dist/pages.js

@@ -0,0 +1,20 @@
+import matter from 'gray-matter';
+import { renderMarkdown } from './markdown.js';
+import { rawPageFiles } from 'cosmolo:content';
+function slugFromPath(filePath, dir) {
+    const prefix = dir.replace(/^\//, '');
+    return filePath.replace(new RegExp(`^/?${prefix}/`), '').replace(/\.md$/, '');
+}
+export function getPageSlugs(config) {
+    return Object.keys(rawPageFiles).map((p) => slugFromPath(p, config.pagesDir));
+}
+export async function getPage(config, slug) {
+    const dir = config.pagesDir.replace(/^\//, '');
+    const filePath = `/${dir}/${slug}.md`;
+    const raw = rawPageFiles[filePath];
+    if (raw === undefined)
+        throw new Error(`Page not found: ${slug}`);
+    const { data, content } = matter(raw);
+    const html = await renderMarkdown(content);
+    return { slug, title: String(data.title ?? slug), html };
+}

package/dist/plugin.d.ts

@@ -0,0 +1,15 @@
+import type { Plugin } from 'vite';
+import type { CosmoloConfig } from './types.js';
+/**
+ * Vite plugin that generates the `cosmolo:content` virtual module.
+ *
+ * Content files are bundled via `import.meta.glob` (evaluated at build time).
+ * JSON config files (categories, site config) are inlined as object literals so
+ * the runtime code has no `fs` dependency — required for Cloudflare Workers and
+ * other serverless runtimes.
+ *
+ * Usage in vite.config.ts:
+ *   import { cosmoloPlugin } from 'cosmolo/plugin';
+ *   plugins: [sveltekit(), cosmoloPlugin({ articlesDir: 'content/articles' })]
+ */
+export declare function cosmoloPlugin(userConfig?: CosmoloConfig): Plugin;

package/{src/plugin.ts → dist/plugin.js}

@@ -1,12 +1,8 @@
 import fs from 'fs';
 import path from 'path';
-import type { Plugin } from 'vite';
-import type { CosmoloConfig } from './types.js';
 import { resolveConfig } from './config.js';
-
 const VIRTUAL_ID = 'cosmolo:content';
 const RESOLVED_ID = '\0cosmolo:content';
-
 /**
  * Vite plugin that generates the `cosmolo:content` virtual module.
  *
@@ -19,30 +15,26 @@ const RESOLVED_ID = '\0cosmolo:content';
  *   import { cosmoloPlugin } from 'cosmolo/plugin';
  *   plugins: [sveltekit(), cosmoloPlugin({ articlesDir: 'content/articles' })]
  */
-export function cosmoloPlugin(userConfig: CosmoloConfig = {}): Plugin {
-	const config = resolveConfig(userConfig);
-
-	const articlesDir = '/' + config.articlesDir.replace(/^\/|\/$/g, '');
-	const pagesDir = '/' + config.pagesDir.replace(/^\/|\/$/g, '');
-
-	const categoriesAbsPath = path.resolve(process.cwd(), config.categoriesConfigPath);
-	const siteConfigAbsPath = path.resolve(process.cwd(), config.siteConfigPath);
-
-	return {
-		name: 'cosmolo',
-		resolveId(id) {
-			if (id === VIRTUAL_ID) return RESOLVED_ID;
-		},
-		load(id) {
-			if (id !== RESOLVED_ID) return;
-
-			this.addWatchFile(categoriesAbsPath);
-			this.addWatchFile(siteConfigAbsPath);
-
-			const categoriesData = JSON.parse(fs.readFileSync(categoriesAbsPath, 'utf-8'));
-			const siteConfigData = JSON.parse(fs.readFileSync(siteConfigAbsPath, 'utf-8'));
-
-			return `
+export function cosmoloPlugin(userConfig = {}) {
+    const config = resolveConfig(userConfig);
+    const articlesDir = '/' + config.articlesDir.replace(/^\/|\/$/g, '');
+    const pagesDir = '/' + config.pagesDir.replace(/^\/|\/$/g, '');
+    const categoriesAbsPath = path.resolve(process.cwd(), config.categoriesConfigPath);
+    const siteConfigAbsPath = path.resolve(process.cwd(), config.siteConfigPath);
+    return {
+        name: 'cosmolo',
+        resolveId(id) {
+            if (id === VIRTUAL_ID)
+                return RESOLVED_ID;
+        },
+        load(id) {
+            if (id !== RESOLVED_ID)
+                return;
+            this.addWatchFile(categoriesAbsPath);
+            this.addWatchFile(siteConfigAbsPath);
+            const categoriesData = JSON.parse(fs.readFileSync(categoriesAbsPath, 'utf-8'));
+            const siteConfigData = JSON.parse(fs.readFileSync(siteConfigAbsPath, 'utf-8'));
+            return `
 export const rawMdFiles = import.meta.glob(
   '${articlesDir}/*.md',
   { query: '?raw', import: 'default', eager: true }
@@ -62,6 +54,6 @@ export const categoriesData = ${JSON.stringify(categoriesData)};
 
 export const siteConfigData = ${JSON.stringify(siteConfigData)};
 `.trim();
-		},
-	};
+        },
+    };
 }

package/dist/types.d.ts

@@ -0,0 +1,58 @@
+export interface CosmoloConfig {
+    /** Directory containing article files (.md, .svx). @default 'src/content/articles' */
+    articlesDir?: string;
+    /** Directory containing static page files (.md). @default 'src/content/pages' */
+    pagesDir?: string;
+    /** Path to site configuration JSON. @default 'config/site.json' */
+    siteConfigPath?: string;
+    /** Path to categories configuration JSON. @default 'config/categories.json' */
+    categoriesConfigPath?: string;
+}
+export type ResolvedCosmoloConfig = Required<CosmoloConfig>;
+export interface TocEntry {
+    level: number;
+    id: string;
+    text: string;
+}
+export interface ArticleFrontmatter {
+    title: string;
+    category: string;
+    excerpt: string;
+    sort: number;
+    date: string;
+    tags: string[];
+    series?: string;
+    seriesOrder?: number;
+    draft: boolean;
+    related: string[];
+}
+export interface Article extends ArticleFrontmatter {
+    slug: string;
+    html: string;
+    markdown: string;
+    toc: TocEntry[];
+}
+export interface Page {
+    slug: string;
+    title: string;
+    html: string;
+}
+export interface CategoryEntry {
+    slug: string;
+    label: string;
+    description: string;
+}
+export interface SiteConfig {
+    url: string;
+    name: string;
+    description: string;
+    twitterHandle: string;
+    fallbackCategoryLabel: string;
+    articlesPerPage: number;
+    ogImage: {
+        mode: 'static' | 'generated';
+    };
+    api: {
+        articleBody: 'html' | 'markdown' | 'plaintext';
+    };
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+// ─── Package configuration ────────────────────────────────────────────────────
+export {};

package/package.json

@@ -1,27 +1,30 @@
 {
 	"name": "cosmolo",
-	"version": "0.3.3",
+	"version": "0.3.4",
 	"type": "module",
 	"bin": {
-		"cosmolo": "src/cli/index.ts"
+		"cosmolo": "./dist/cli/index.js"
 	},
 	"exports": {
 		".": {
-			"types": "./src/index.ts",
-			"default": "./src/index.ts"
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
 		},
 		"./plugin": {
-			"types": "./src/plugin.ts",
-			"default": "./src/plugin.ts"
+			"types": "./dist/plugin.d.ts",
+			"default": "./dist/plugin.js"
 		}
 	},
 	"files": [
-		"src",
+		"dist",
 		"templates",
 		"README.md",
-		"LICENSE",
-		"!src/**/*.test.ts"
+		"LICENSE"
 	],
+	"scripts": {
+		"build": "tsc && cp src/virtual.d.ts dist/virtual.d.ts && chmod +x dist/cli/index.js",
+		"prepublishOnly": "npm run build"
+	},
 	"dependencies": {
 		"gray-matter": "^4.0.3",
 		"marked": "^15.0.0",

package/src/articles.ts

@@ -1,124 +0,0 @@
-import { z } from 'zod';
-import matter from 'gray-matter';
-import { renderMarkdown, generateToc } from './markdown.js';
-import { isKnownCategory } from './categories.js';
-import type { Article, ResolvedCosmoloConfig } from './types.js';
-import { rawMdFiles, svxModules } from 'cosmolo:content';
-
-export const articleFrontmatterSchema = z.object({
-	title: z.string(),
-	category: z.string(),
-	excerpt: z.string(),
-	sort: z.number().default(0),
-	date: z.preprocess(
-		(val) => (val instanceof Date ? val.toISOString().split('T')[0] : val),
-		z.string().default('')
-	),
-	tags: z.array(z.string()).default([]),
-	series: z.string().optional(),
-	seriesOrder: z.number().optional(),
-	draft: z.boolean().default(false),
-	related: z.array(z.string()).default([]),
-});
-
-function slugFromPath(filePath: string, dir: string): string {
-	const prefix = dir.replace(/^\//, '');
-	return filePath
-		.replace(new RegExp(`^/?${prefix}/`), '')
-		.replace(/\.(md|svx)$/, '');
-}
-
-/** Returns all non-draft articles sorted by `sort` descending. */
-export function getArticles(config: ResolvedCosmoloConfig): Article[] {
-	const articles: Article[] = [];
-
-	for (const [filePath, raw] of Object.entries(rawMdFiles)) {
-		const slug = slugFromPath(filePath, config.articlesDir);
-		const { data } = matter(raw);
-		const frontmatter = articleFrontmatterSchema.parse(data);
-		if (frontmatter.draft) continue;
-		articles.push({ ...frontmatter, slug, html: '', markdown: '', toc: [] });
-	}
-
-	for (const [filePath, mod] of Object.entries(svxModules)) {
-		const slug = slugFromPath(filePath, config.articlesDir);
-		const frontmatter = articleFrontmatterSchema.parse(
-			(mod as { metadata: Record<string, unknown> }).metadata
-		);
-		if (frontmatter.draft) continue;
-		articles.push({ ...frontmatter, slug, html: '', markdown: '', toc: [] });
-	}
-
-	return articles.sort((a, b) => b.sort - a.sort);
-}
-
-/** Returns all non-draft article slugs. */
-export function getSlugs(config: ResolvedCosmoloConfig): string[] {
-	return getArticles(config).map((a) => a.slug);
-}
-
-/** Returns a single article with rendered HTML and TOC. Draft articles are included. */
-export async function getArticle(config: ResolvedCosmoloConfig, slug: string): Promise<Article> {
-	const dir = config.articlesDir.replace(/^\//, '');
-	const mdPath = `/${dir}/${slug}.md`;
-	const svxPath = `/${dir}/${slug}.svx`;
-
-	if (rawMdFiles[mdPath] !== undefined) {
-		const raw = rawMdFiles[mdPath];
-		const { data, content } = matter(raw);
-		const frontmatter = articleFrontmatterSchema.parse(data);
-		const html = await renderMarkdown(content);
-		const toc = generateToc(content);
-		return { ...frontmatter, slug, html, markdown: content, toc };
-	}
-
-	if (svxModules[svxPath] !== undefined) {
-		const frontmatter = articleFrontmatterSchema.parse(
-			(svxModules[svxPath] as { metadata: Record<string, unknown> }).metadata
-		);
-		return { ...frontmatter, slug, html: '', markdown: '', toc: [] };
-	}
-
-	throw new Error(`Article not found: ${slug}`);
-}
-
-export function getArticlesByCategory(
-	config: ResolvedCosmoloConfig,
-	categorySlug: string,
-	excludeSlug?: string
-): Article[] {
-	const all = getArticles(config);
-	const filtered =
-		categorySlug === 'other'
-			? all.filter((a) => !isKnownCategory(config, a.category))
-			: all.filter((a) => a.category === categorySlug);
-	return excludeSlug ? filtered.filter((a) => a.slug !== excludeSlug) : filtered;
-}
-
-export function getArticlesByTag(config: ResolvedCosmoloConfig, tag: string): Article[] {
-	return getArticles(config).filter((a) => a.tags.includes(tag));
-}
-
-export function getArticlesBySeries(config: ResolvedCosmoloConfig, seriesKey: string): Article[] {
-	return getArticles(config)
-		.filter((a) => a.series === seriesKey)
-		.sort((a, b) => (a.seriesOrder ?? 0) - (b.seriesOrder ?? 0));
-}
-
-export function getTags(config: ResolvedCosmoloConfig): string[] {
-	const tags = new Set<string>();
-	getArticles(config).forEach((a) => a.tags.forEach((t) => tags.add(t)));
-	return Array.from(tags).sort();
-}
-
-/**
- * Returns the Svelte component constructor for an .svx article, or undefined
- * if the article is a plain .md file. Safe to call from Svelte components.
- */
-export function getSvxComponent(
-	config: ResolvedCosmoloConfig,
-	slug: string
-): unknown | undefined {
-	const dir = '/' + config.articlesDir.replace(/^\/|\/$/g, '');
-	return (svxModules[`${dir}/${slug}.svx`] as { default: unknown } | undefined)?.default;
-}

package/src/categories.ts

@@ -1,35 +0,0 @@
-import { categoriesData, siteConfigData } from 'cosmolo:content';
-import type { CategoryEntry, ResolvedCosmoloConfig, SiteConfig } from './types.js';
-
-type CategoriesMap = Record<string, { label: string; description: string }>;
-
-const map = categoriesData as CategoriesMap;
-
-export function getAllCategories(_config: ResolvedCosmoloConfig): CategoryEntry[] {
-	return Object.entries(map).map(([slug, { label, description }]) => ({
-		slug,
-		label,
-		description,
-	}));
-}
-
-export function isKnownCategory(_config: ResolvedCosmoloConfig, key: string): boolean {
-	return Object.prototype.hasOwnProperty.call(map, key);
-}
-
-export function getCategoryLabel(_config: ResolvedCosmoloConfig, key: string): string {
-	if (Object.prototype.hasOwnProperty.call(map, key)) return map[key].label;
-	return (siteConfigData as SiteConfig).fallbackCategoryLabel;
-}
-
-export function getCategoryDescription(_config: ResolvedCosmoloConfig, key: string): string {
-	return map[key]?.description ?? '';
-}
-
-export function getCategorySlugs(_config: ResolvedCosmoloConfig): string[] {
-	return [...Object.keys(map), 'other'];
-}
-
-export function loadSiteConfig(_config: ResolvedCosmoloConfig): SiteConfig {
-	return siteConfigData as SiteConfig;
-}