cosmolo 0.3.3 → 0.3.4

package/dist/articles.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import type { Article, ResolvedCosmoloConfig } from './types.js';
+export declare const articleFrontmatterSchema: z.ZodObject<{
+    title: z.ZodString;
+    category: z.ZodString;
+    excerpt: z.ZodString;
+    sort: z.ZodDefault<z.ZodNumber>;
+    date: z.ZodEffects<z.ZodDefault<z.ZodString>, string, unknown>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    series: z.ZodOptional<z.ZodString>;
+    seriesOrder: z.ZodOptional<z.ZodNumber>;
+    draft: z.ZodDefault<z.ZodBoolean>;
+    related: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    category: string;
+    excerpt: string;
+    sort: number;
+    date: string;
+    tags: string[];
+    draft: boolean;
+    related: string[];
+    series?: string | undefined;
+    seriesOrder?: number | undefined;
+}, {
+    title: string;
+    category: string;
+    excerpt: string;
+    sort?: number | undefined;
+    date?: unknown;
+    tags?: string[] | undefined;
+    series?: string | undefined;
+    seriesOrder?: number | undefined;
+    draft?: boolean | undefined;
+    related?: string[] | undefined;
+}>;
+/** Returns all non-draft articles sorted by `sort` descending. */
+export declare function getArticles(config: ResolvedCosmoloConfig): Article[];
+/** Returns all non-draft article slugs. */
+export declare function getSlugs(config: ResolvedCosmoloConfig): string[];
+/** Returns a single article with rendered HTML and TOC. Draft articles are included. */
+export declare function getArticle(config: ResolvedCosmoloConfig, slug: string): Promise<Article>;
+export declare function getArticlesByCategory(config: ResolvedCosmoloConfig, categorySlug: string, excludeSlug?: string): Article[];
+export declare function getArticlesByTag(config: ResolvedCosmoloConfig, tag: string): Article[];
+export declare function getArticlesBySeries(config: ResolvedCosmoloConfig, seriesKey: string): Article[];
+export declare function getTags(config: ResolvedCosmoloConfig): string[];
+/**
+ * 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 declare function getSvxComponent(config: ResolvedCosmoloConfig, slug: string): unknown | undefined;

package/dist/articles.js

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import matter from 'gray-matter';
+import { renderMarkdown, generateToc } from './markdown.js';
+import { isKnownCategory } from './categories.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, dir) {
+    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) {
+    const articles = [];
+    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.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) {
+    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, slug) {
+    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].metadata);
+        return { ...frontmatter, slug, html: '', markdown: '', toc: [] };
+    }
+    throw new Error(`Article not found: ${slug}`);
+}
+export function getArticlesByCategory(config, categorySlug, excludeSlug) {
+    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, tag) {
+    return getArticles(config).filter((a) => a.tags.includes(tag));
+}
+export function getArticlesBySeries(config, seriesKey) {
+    return getArticles(config)
+        .filter((a) => a.series === seriesKey)
+        .sort((a, b) => (a.seriesOrder ?? 0) - (b.seriesOrder ?? 0));
+}
+export function getTags(config) {
+    const tags = new Set();
+    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, slug) {
+    const dir = '/' + config.articlesDir.replace(/^\/|\/$/g, '');
+    return svxModules[`${dir}/${slug}.svx`]?.default;
+}

package/dist/categories.d.ts

@@ -0,0 +1,7 @@
+import type { CategoryEntry, ResolvedCosmoloConfig, SiteConfig } from './types.js';
+export declare function getAllCategories(_config: ResolvedCosmoloConfig): CategoryEntry[];
+export declare function isKnownCategory(_config: ResolvedCosmoloConfig, key: string): boolean;
+export declare function getCategoryLabel(_config: ResolvedCosmoloConfig, key: string): string;
+export declare function getCategoryDescription(_config: ResolvedCosmoloConfig, key: string): string;
+export declare function getCategorySlugs(_config: ResolvedCosmoloConfig): string[];
+export declare function loadSiteConfig(_config: ResolvedCosmoloConfig): SiteConfig;

package/dist/categories.js

@@ -0,0 +1,26 @@
+import { categoriesData, siteConfigData } from 'cosmolo:content';
+const map = categoriesData;
+export function getAllCategories(_config) {
+    return Object.entries(map).map(([slug, { label, description }]) => ({
+        slug,
+        label,
+        description,
+    }));
+}
+export function isKnownCategory(_config, key) {
+    return Object.prototype.hasOwnProperty.call(map, key);
+}
+export function getCategoryLabel(_config, key) {
+    if (Object.prototype.hasOwnProperty.call(map, key))
+        return map[key].label;
+    return siteConfigData.fallbackCategoryLabel;
+}
+export function getCategoryDescription(_config, key) {
+    return map[key]?.description ?? '';
+}
+export function getCategorySlugs(_config) {
+    return [...Object.keys(map), 'other'];
+}
+export function loadSiteConfig(_config) {
+    return siteConfigData;
+}

package/dist/cli/generate.d.ts

@@ -0,0 +1 @@
+export declare function main(): Promise<void>;

package/dist/cli/generate.js

@@ -0,0 +1,171 @@
+import * as readline from 'readline';
+import * as fs from 'fs';
+import * as path from 'path';
+import { DEFAULT_CONFIG } from '../config.js';
+// ─── config ──────────────────────────────────────────────────────────────────
+async function loadConfig() {
+    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;
+            }
+            catch {
+                // fall through to defaults
+            }
+        }
+    }
+    return DEFAULT_CONFIG;
+}
+// ─── helpers ─────────────────────────────────────────────────────────────────
+function ask(rl, question, fallback = '') {
+    const hint = fallback ? ` [${fallback}]` : '';
+    return new Promise((resolve) => rl.question(`  ${question}${hint}: `, (ans) => resolve(ans.trim() || fallback)));
+}
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\w\s-]/g, '')
+        .trim()
+        .replace(/[\s_]+/g, '-')
+        .replace(/-+/g, '-');
+}
+function today() {
+    return new Date().toISOString().split('T')[0];
+}
+function readCategories(config) {
+    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, config) {
+    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, config) {
+    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, config) {
+    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() {
+    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 = {
+        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((resolve) => rl.question('\nWhat would you like to generate? (1/2/3): ', (ans) => resolve(ans.trim())));
+            const picked = { '1': generateArticle, '2': generatePage, '3': generateCategory }[choice];
+            if (!picked) {
+                console.error('Invalid choice.');
+                process.exit(1);
+            }
+            await picked(rl, config);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/cli/index.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env bun
+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);
+    }
+}
+export {};

package/dist/cli/init.d.ts

@@ -0,0 +1 @@
+export declare function main(): Promise<void>;

package/dist/cli/init.js

@@ -0,0 +1,154 @@
+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, question) {
+    return new Promise((resolve) => rl.question(question, resolve));
+}
+function copyFile(src, dest) {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(src, dest);
+}
+function writeFile(dest, content) {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.writeFileSync(dest, content, 'utf-8');
+}
+function collectFiles(dir) {
+    const results = [];
+    function walk(current) {
+        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, projectRoot) {
+    const mapped = relativePath
+        .replace(/^routes\//, 'src/routes/')
+        .replace(/^lib\//, 'src/lib/');
+    return path.join(projectRoot, mapped);
+}
+function injectPackageScripts(projectRoot) {
+    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 = {
+        '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() {
+    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 = 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 = [
+        ...sharedFiles.map(([src, rel]) => [src, rel]),
+        ...fullFiles.map(([src, rel]) => [src, rel]),
+    ];
+    const layoutTsPath = path.join(PROJECT_ROOT, 'src/routes/+layout.ts');
+    const layoutTsContent = 'export const prerender = true;\n';
+    // ── Conflict detection ──────────────────────────────────────────────────
+    const conflicts = [];
+    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/dist/config.d.ts

@@ -0,0 +1,3 @@
+import type { CosmoloConfig, ResolvedCosmoloConfig } from './types.js';
+export declare const DEFAULT_CONFIG: ResolvedCosmoloConfig;
+export declare function resolveConfig(userConfig?: CosmoloConfig): ResolvedCosmoloConfig;

package/dist/config.js

@@ -0,0 +1,9 @@
+export const DEFAULT_CONFIG = {
+    articlesDir: 'src/content/articles',
+    pagesDir: 'src/content/pages',
+    siteConfigPath: 'config/site.json',
+    categoriesConfigPath: 'config/categories.json',
+};
+export function resolveConfig(userConfig = {}) {
+    return { ...DEFAULT_CONFIG, ...userConfig };
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+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/dist/index.js

@@ -0,0 +1,6 @@
+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';