cosmolo 0.3.3 → 0.3.4

package/src/cli/generate.ts

@@ -1,190 +0,0 @@
-import * as readline from 'readline';
-import * as fs from 'fs';
-import * as path from 'path';
-import { DEFAULT_CONFIG } from '../config.js';
-import type { ResolvedCosmoloConfig } from '../types.js';
-
-// ─── config ──────────────────────────────────────────────────────────────────
-
-async function loadConfig(): Promise<ResolvedCosmoloConfig> {
-	const root = process.cwd();
-	for (const name of ['cosmolo.config.ts', 'cosmolo.config.js']) {
-		const p = path.join(root, name);
-		if (fs.existsSync(p)) {
-			try {
-				const mod = await import(p);
-				return mod.default as ResolvedCosmoloConfig;
-			} catch {
-				// fall through to defaults
-			}
-		}
-	}
-	return DEFAULT_CONFIG;
-}
-
-// ─── helpers ─────────────────────────────────────────────────────────────────
-
-function ask(rl: readline.Interface, question: string, fallback = ''): Promise<string> {
-	const hint = fallback ? ` [${fallback}]` : '';
-	return new Promise((resolve) =>
-		rl.question(`  ${question}${hint}: `, (ans) => resolve(ans.trim() || fallback))
-	);
-}
-
-function slugify(text: string): string {
-	return text
-		.toLowerCase()
-		.replace(/[^\w\s-]/g, '')
-		.trim()
-		.replace(/[\s_]+/g, '-')
-		.replace(/-+/g, '-');
-}
-
-function today(): string {
-	return new Date().toISOString().split('T')[0];
-}
-
-function readCategories(config: ResolvedCosmoloConfig): Record<string, { label: string; description: string }> {
-	const p = path.resolve(process.cwd(), config.categoriesConfigPath);
-	if (!fs.existsSync(p)) return {};
-	return JSON.parse(fs.readFileSync(p, 'utf-8'));
-}
-
-// ─── generators ──────────────────────────────────────────────────────────────
-
-async function generateArticle(rl: readline.Interface, config: ResolvedCosmoloConfig): Promise<void> {
-	console.log('\nGenerate Article\n');
-
-	const title = await ask(rl, 'Title');
-	if (!title) { console.error('\nError: Title is required.'); process.exit(1); }
-
-	const defaultSlug = slugify(title);
-	const slug = await ask(rl, 'Slug', defaultSlug);
-
-	const articlesDir = path.resolve(process.cwd(), config.articlesDir);
-	const filePath = path.join(articlesDir, `${slug}.md`);
-
-	if (fs.existsSync(filePath)) {
-		console.error(`\nError: ${config.articlesDir}/${slug}.md already exists.`);
-		process.exit(1);
-	}
-
-	const categories = readCategories(config);
-	const catKeys = Object.keys(categories);
-	if (catKeys.length > 0) console.log(`\n  Categories: ${catKeys.join(', ')}`);
-
-	const category    = await ask(rl, 'Category', catKeys[0] ?? 'other');
-	const excerpt     = await ask(rl, 'Excerpt', '');
-	const tagsRaw     = await ask(rl, 'Tags (comma-separated)', '');
-	const tags        = tagsRaw ? tagsRaw.split(',').map((t) => t.trim()).filter(Boolean) : [];
-	const sort        = await ask(rl, 'Sort', '0');
-	const date        = await ask(rl, 'Date', today());
-	const draftAns    = await ask(rl, 'Draft? (y/N)', 'N');
-	const draft       = draftAns.toLowerCase() === 'y';
-	const series      = await ask(rl, 'Series (optional)', '');
-	const seriesOrder = series ? await ask(rl, 'Series order', '1') : '';
-
-	const lines = [
-		'---',
-		`title: "${title}"`,
-		`category: "${category}"`,
-		`excerpt: "${excerpt}"`,
-		`sort: ${parseInt(sort, 10) || 0}`,
-		`date: "${date}"`,
-	];
-	if (tags.length > 0) lines.push(`tags: [${tags.map((t) => `"${t}"`).join(', ')}]`);
-	if (series) {
-		lines.push(`series: "${series}"`);
-		lines.push(`seriesOrder: ${parseInt(seriesOrder, 10) || 1}`);
-	}
-	if (draft) lines.push('draft: true');
-	lines.push('---', '', '');
-
-	fs.mkdirSync(articlesDir, { recursive: true });
-	fs.writeFileSync(filePath, lines.join('\n'));
-	console.log(`\nCreated: ${config.articlesDir}/${slug}.md`);
-}
-
-async function generatePage(rl: readline.Interface, config: ResolvedCosmoloConfig): Promise<void> {
-	console.log('\nGenerate Page\n');
-
-	const title = await ask(rl, 'Title');
-	if (!title) { console.error('\nError: Title is required.'); process.exit(1); }
-
-	const defaultSlug = slugify(title);
-	const slug = await ask(rl, 'Slug', defaultSlug);
-
-	const pagesDir = path.resolve(process.cwd(), config.pagesDir);
-	const filePath = path.join(pagesDir, `${slug}.md`);
-
-	if (fs.existsSync(filePath)) {
-		console.error(`\nError: ${config.pagesDir}/${slug}.md already exists.`);
-		process.exit(1);
-	}
-
-	const content = ['---', `title: "${title}"`, '---', '', ''].join('\n');
-	fs.mkdirSync(pagesDir, { recursive: true });
-	fs.writeFileSync(filePath, content);
-	console.log(`\nCreated: ${config.pagesDir}/${slug}.md`);
-}
-
-async function generateCategory(rl: readline.Interface, config: ResolvedCosmoloConfig): Promise<void> {
-	console.log('\nGenerate Category\n');
-
-	const key = await ask(rl, 'Key (slug)');
-	if (!key) { console.error('\nError: Key is required.'); process.exit(1); }
-
-	const categoriesPath = path.resolve(process.cwd(), config.categoriesConfigPath);
-	const categories = readCategories(config);
-
-	if (categories[key]) {
-		console.error(`\nError: Category "${key}" already exists.`);
-		process.exit(1);
-	}
-
-	const label       = await ask(rl, 'Label');
-	const description = await ask(rl, 'Description', '');
-
-	categories[key] = { label, description };
-	fs.mkdirSync(path.dirname(categoriesPath), { recursive: true });
-	fs.writeFileSync(categoriesPath, JSON.stringify(categories, null, '\t') + '\n');
-	console.log(`\nAdded: "${key}" to ${config.categoriesConfigPath}`);
-}
-
-// ─── main ─────────────────────────────────────────────────────────────────────
-
-export async function main(): Promise<void> {
-	const config = await loadConfig();
-	const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-
-	const subcommand = process.argv[3]; // argv[2] is "generate"
-
-	const commands: Record<string, (rl: readline.Interface, config: ResolvedCosmoloConfig) => Promise<void>> = {
-		article:  generateArticle,
-		page:     generatePage,
-		category: generateCategory,
-	};
-
-	try {
-		if (subcommand && commands[subcommand]) {
-			await commands[subcommand](rl, config);
-		} else if (subcommand) {
-			console.error(`Unknown subcommand: ${subcommand}`);
-			console.error('Available: article, page, category');
-			process.exit(1);
-		} else {
-			console.log('Cosmolo Generator\n');
-			console.log('  1. Article');
-			console.log('  2. Page');
-			console.log('  3. Category');
-			const choice = await new Promise<string>((resolve) =>
-				rl.question('\nWhat would you like to generate? (1/2/3): ', (ans) => resolve(ans.trim()))
-			);
-			const picked = ({ '1': generateArticle, '2': generatePage, '3': generateCategory } as Record<string, typeof generateArticle>)[choice];
-			if (!picked) { console.error('Invalid choice.'); process.exit(1); }
-			await picked(rl, config);
-		}
-	} finally {
-		rl.close();
-	}
-}

package/src/cli/index.ts

@@ -1,22 +0,0 @@
-#!/usr/bin/env bun
-export {};
-
-const cmd = process.argv[2];
-
-switch (cmd) {
-	case 'init':
-		await (await import('./init.js')).main();
-		break;
-	case 'generate':
-		await (await import('./generate.js')).main();
-		break;
-	default: {
-		const isUnknown = Boolean(cmd);
-		if (isUnknown) console.error(`Unknown command: ${cmd}\n`);
-		console.log('Usage: cosmolo <command>\n');
-		console.log('Commands:');
-		console.log('  init                             Scaffold routes into an existing SvelteKit project');
-		console.log('  generate [article|page|category] Create content files');
-		process.exit(isUnknown ? 1 : 0);
-	}
-}

package/src/cli/init.ts

@@ -1,175 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as readline from 'readline';
-import { fileURLToPath } from 'url';
-
-// ─── helpers ─────────────────────────────────────────────────────────────────
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const TEMPLATE_DIR = path.resolve(__dirname, '../../templates');
-
-function ask(rl: readline.Interface, question: string): Promise<string> {
-	return new Promise((resolve) => rl.question(question, resolve));
-}
-
-function copyFile(src: string, dest: string): void {
-	fs.mkdirSync(path.dirname(dest), { recursive: true });
-	fs.copyFileSync(src, dest);
-}
-
-function writeFile(dest: string, content: string): void {
-	fs.mkdirSync(path.dirname(dest), { recursive: true });
-	fs.writeFileSync(dest, content, 'utf-8');
-}
-
-function collectFiles(dir: string): Array<[string, string]> {
-	const results: Array<[string, string]> = [];
-	function walk(current: string) {
-		for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
-			const full = path.join(current, entry.name);
-			if (entry.isDirectory()) walk(full);
-			else results.push([full, path.relative(dir, full)]);
-		}
-	}
-	walk(dir);
-	return results;
-}
-
-function destPath(relativePath: string, projectRoot: string): string {
-	const mapped = relativePath
-		.replace(/^routes\//, 'src/routes/')
-		.replace(/^lib\//, 'src/lib/');
-	return path.join(projectRoot, mapped);
-}
-
-function injectPackageScripts(projectRoot: string): void {
-	const pkgPath = path.join(projectRoot, 'package.json');
-	if (!fs.existsSync(pkgPath)) return;
-
-	const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-	pkg.scripts = pkg.scripts ?? {};
-
-	let added = false;
-	const scripts: Record<string, string> = {
-		'generate:article':  'cosmolo generate article',
-		'generate:page':     'cosmolo generate page',
-		'generate:category': 'cosmolo generate category',
-	};
-	for (const [key, val] of Object.entries(scripts)) {
-		if (!pkg.scripts[key]) {
-			pkg.scripts[key] = val;
-			added = true;
-		}
-	}
-
-	if (added) {
-		fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, '\t') + '\n');
-		console.log('  updated  package.json (added generate:* scripts)');
-	}
-}
-
-// ─── main ─────────────────────────────────────────────────────────────────────
-
-export async function main(): Promise<void> {
-	const PROJECT_ROOT = process.cwd();
-	const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-
-	console.log('\ncosmolo init\n');
-
-	// ── Mode selection ──────────────────────────────────────────────────────
-	console.log('Choose an initialization mode:\n');
-	console.log('  1) Full  — server routes + Svelte page components');
-	console.log('  2) Slim  — server routes only (bring your own Svelte UI)\n');
-
-	let modeRaw = '';
-	while (!['1', '2'].includes(modeRaw)) {
-		modeRaw = (await ask(rl, 'Mode [1/2]: ')).trim();
-		if (!['1', '2'].includes(modeRaw)) console.log('  Please enter 1 or 2.');
-	}
-	const mode: 'full' | 'slim' = modeRaw === '1' ? 'full' : 'slim';
-
-	// ── Adapter selection ───────────────────────────────────────────────────
-	console.log('\nChoose your deployment adapter:\n');
-	console.log('  1) SSG              — @sveltejs/adapter-static (Cloudflare Pages static, GitHub Pages, etc.)');
-	console.log('  2) Serverless/SSR   — Cloudflare Workers, Vercel, Node, etc.\n');
-
-	let adapterRaw = '';
-	while (!['1', '2'].includes(adapterRaw)) {
-		adapterRaw = (await ask(rl, 'Adapter [1/2]: ')).trim();
-		if (!['1', '2'].includes(adapterRaw)) console.log('  Please enter 1 or 2.');
-	}
-	const isSSG = adapterRaw === '1';
-
-	// ── Collect files ───────────────────────────────────────────────────────
-	const sharedFiles = collectFiles(path.join(TEMPLATE_DIR, 'shared'));
-	const fullFiles = mode === 'full' ? collectFiles(path.join(TEMPLATE_DIR, 'full')) : [];
-
-	const allFiles: Array<[string, string]> = [
-		...sharedFiles.map(([src, rel]) => [src, rel] as [string, string]),
-		...fullFiles.map(([src, rel]) => [src, rel] as [string, string]),
-	];
-
-	const layoutTsPath = path.join(PROJECT_ROOT, 'src/routes/+layout.ts');
-	const layoutTsContent = 'export const prerender = true;\n';
-
-	// ── Conflict detection ──────────────────────────────────────────────────
-	const conflicts: string[] = [];
-
-	for (const [, rel] of allFiles) {
-		const dest = destPath(rel, PROJECT_ROOT);
-		if (fs.existsSync(dest)) conflicts.push(path.relative(PROJECT_ROOT, dest));
-	}
-	if (isSSG && fs.existsSync(layoutTsPath)) {
-		conflicts.push(path.relative(PROJECT_ROOT, layoutTsPath));
-	}
-
-	if (conflicts.length > 0) {
-		console.log('\nThe following files already exist:\n');
-		for (const f of conflicts) console.log(`  ${f}`);
-
-		let overwriteRaw = '';
-		while (!['y', 'n'].includes(overwriteRaw)) {
-			overwriteRaw = (await ask(rl, '\nOverwrite all? [y/N]: ')).trim().toLowerCase() || 'n';
-			if (!['y', 'n'].includes(overwriteRaw)) console.log('  Please enter y or n.');
-		}
-
-		if (overwriteRaw === 'n') {
-			console.log('\nAborted. No files were written.\n');
-			rl.close();
-			process.exit(0);
-		}
-	}
-
-	rl.close();
-
-	// ── Write files ─────────────────────────────────────────────────────────
-	for (const [src, rel] of allFiles) {
-		const dest = destPath(rel, PROJECT_ROOT);
-		copyFile(src, dest);
-		console.log(`  created  ${path.relative(PROJECT_ROOT, dest)}`);
-	}
-
-	if (isSSG) {
-		writeFile(layoutTsPath, layoutTsContent);
-		console.log(`  created  src/routes/+layout.ts`);
-	}
-
-	injectPackageScripts(PROJECT_ROOT);
-
-	// ── Next steps ──────────────────────────────────────────────────────────
-	console.log('\nDone! Next steps:\n');
-	console.log('  1. Install cosmolo:  npm install cosmolo  (or bun add cosmolo)');
-	if (isSSG) {
-		console.log('  2. Install adapter:  npm install -D @sveltejs/adapter-static');
-	} else {
-		console.log('  2. Install adapter:  npm install -D @sveltejs/adapter-cloudflare  (or your adapter)');
-	}
-	if (mode === 'full') {
-		console.log('  3. Install sass:     npm install -D sass  (SCSS used in Svelte templates)');
-		console.log('  4. Run:              npm run dev');
-	} else {
-		console.log('  3. Add your own +page.svelte files for each route.');
-		console.log('  4. Run:              npm run dev');
-	}
-	console.log('\n  See https://github.com/alcogy/cosmolo for full documentation.\n');
-}

package/src/config.ts

@@ -1,12 +0,0 @@
-import type { CosmoloConfig, ResolvedCosmoloConfig } from './types.js';
-
-export const DEFAULT_CONFIG: ResolvedCosmoloConfig = {
-	articlesDir: 'src/content/articles',
-	pagesDir: 'src/content/pages',
-	siteConfigPath: 'config/site.json',
-	categoriesConfigPath: 'config/categories.json',
-};
-
-export function resolveConfig(userConfig: CosmoloConfig = {}): ResolvedCosmoloConfig {
-	return { ...DEFAULT_CONFIG, ...userConfig };
-}

package/src/index.ts

@@ -1,34 +0,0 @@
-export type {
-	CosmoloConfig,
-	ResolvedCosmoloConfig,
-	TocEntry,
-	ArticleFrontmatter,
-	Article,
-	Page,
-	CategoryEntry,
-	SiteConfig,
-} from './types.js';
-
-export { DEFAULT_CONFIG, resolveConfig } from './config.js';
-export {
-	getAllCategories,
-	isKnownCategory,
-	getCategoryLabel,
-	getCategoryDescription,
-	getCategorySlugs,
-	loadSiteConfig,
-} from './categories.js';
-export { articleFrontmatterSchema, getArticles, getArticle, getSlugs, getArticlesByCategory, getArticlesByTag, getArticlesBySeries, getTags, getSvxComponent } from './articles.js';
-export { getPageSlugs, getPage } from './pages.js';
-export { renderMarkdown, generateToc } from './markdown.js';
-export {
-	createArticlesLoader,
-	createArticleLoader,
-	createCategoryLoader,
-	createTagLoader,
-	createPageLoader,
-	createArticleEntries,
-	createCategoryEntries,
-	createTagEntries,
-	createPageEntries,
-} from './loaders.js';

package/src/loaders.ts

@@ -1,135 +0,0 @@
-import { getArticle, getArticles, getArticlesByCategory, getArticlesBySeries, getArticlesByTag, getSlugs, getTags } from './articles.js';
-import { getCategorySlugs, getCategoryLabel, getCategoryDescription } from './categories.js';
-import { getPage, getPageSlugs } from './pages.js';
-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 function createArticlesLoader(config: ResolvedCosmoloConfig) {
-	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: ResolvedCosmoloConfig,
-	options: { getUpdatedAt?: (slug: string) => string } = {}
-) {
-	return async ({ params }: { params: { slug: string } }) => {
-		const article = await getArticle(config, params.slug);
-		const updatedAt = options.getUpdatedAt?.(params.slug) ?? '';
-
-		let related: Article[];
-		if (article.related.length > 0) {
-			const all = getArticles(config);
-			related = article.related
-				.map((s) => all.find((a) => a.slug === s))
-				.filter((a): a is Article => a !== undefined)
-				.slice(0, 4);
-		} else {
-			related = getArticlesByCategory(config, article.category, params.slug).slice(0, 4);
-		}
-
-		let seriesPrev: Article | null = null;
-		let seriesNext: Article | null = 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: ResolvedCosmoloConfig) {
-	return ({ params }: { params: { slug: string } }) => {
-		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: ResolvedCosmoloConfig) {
-	return ({ params }: { params: { tag: string } }) => ({
-		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: ResolvedCosmoloConfig) {
-	return async ({ params }: { params: { slug: string } }) => ({
-		page: await getPage(config, params.slug),
-	});
-}
-
-// ─── entries generators ───────────────────────────────────────────────────────
-
-export function createArticleEntries(config: ResolvedCosmoloConfig) {
-	return () => getSlugs(config).map((slug) => ({ slug }));
-}
-
-export function createCategoryEntries(config: ResolvedCosmoloConfig) {
-	return () => getCategorySlugs(config).map((slug) => ({ slug }));
-}
-
-export function createTagEntries(config: ResolvedCosmoloConfig) {
-	return () => getTags(config).map((tag) => ({ tag }));
-}
-
-export function createPageEntries(config: ResolvedCosmoloConfig) {
-	return () => getPageSlugs(config).map((slug) => ({ slug }));
-}

package/src/markdown.ts

@@ -1,74 +0,0 @@
-import { marked } from 'marked';
-import type { TocEntry } from './types.js';
-
-function slugifyHeading(text: string): string {
-	return text
-		.toLowerCase()
-		.replace(/<[^>]+>/g, '')
-		.replace(/[^\w\s-]/g, '')
-		.trim()
-		.replace(/\s+/g, '-');
-}
-
-marked.use({
-	extensions: [
-		{
-			name: 'youtube',
-			level: 'block',
-			start(src: string) {
-				return src.indexOf('::youtube[');
-			},
-			tokenizer(src: string) {
-				const match = /^::youtube\[([^\]]+)\]/.exec(src);
-				if (match) return { type: 'youtube', raw: match[0], videoId: match[1].trim() };
-			},
-			renderer(token) {
-				const { videoId } = token as unknown as { videoId: string };
-				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 }: { href: string; title?: string | null; text: string }) {
-			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 }: { text: string; depth: number }) {
-			const id = slugifyHeading(text);
-			return `<h${depth} id="${id}">${text}</h${depth}>\n`;
-		},
-	},
-});
-
-export async function renderMarkdown(content: string): Promise<string> {
-	return marked.parse(content);
-}
-
-export function generateToc(content: string): TocEntry[] {
-	const entries: TocEntry[] = [];
-	const seenIds = new Map<string, number>();
-	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/src/pages.ts

@@ -1,23 +0,0 @@
-import matter from 'gray-matter';
-import { renderMarkdown } from './markdown.js';
-import type { Page, ResolvedCosmoloConfig } from './types.js';
-import { rawPageFiles } from 'cosmolo:content';
-
-function slugFromPath(filePath: string, dir: string): string {
-	const prefix = dir.replace(/^\//, '');
-	return filePath.replace(new RegExp(`^/?${prefix}/`), '').replace(/\.md$/, '');
-}
-
-export function getPageSlugs(config: ResolvedCosmoloConfig): string[] {
-	return Object.keys(rawPageFiles).map((p) => slugFromPath(p, config.pagesDir));
-}
-
-export async function getPage(config: ResolvedCosmoloConfig, slug: string): Promise<Page> {
-	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 };
-}