@aureuma/svelta 0.0.1 → 0.1.0

package/package.json

@@ -1,8 +1,37 @@
 {
 	"name": "@aureuma/svelta",
 	"private": false,
-	"version": "0.0.1",
+	"version": "0.1.0",
 	"type": "module",
+	"files": [
+		"packages/blogkit/dist",
+		"packages/blogkit/README.md",
+		"packages/blogkit/CHANGELOG.md",
+		"LICENSE",
+		"README.md"
+	],
+	"exports": {
+		".": {
+			"types": "./packages/blogkit/dist/index.d.ts",
+			"svelte": "./packages/blogkit/dist/index.js",
+			"default": "./packages/blogkit/dist/index.js"
+		},
+		"./server": {
+			"types": "./packages/blogkit/dist/server/index.d.ts",
+			"default": "./packages/blogkit/dist/server/index.js"
+		},
+		"./theme": {
+			"types": "./packages/blogkit/dist/theme/index.d.ts",
+			"svelte": "./packages/blogkit/dist/theme/index.js",
+			"default": "./packages/blogkit/dist/theme/index.js"
+		}
+	},
+	"types": "./packages/blogkit/dist/index.d.ts",
+	"main": "./packages/blogkit/dist/index.js",
+	"svelte": "./packages/blogkit/dist/index.js",
+	"peerDependencies": {
+		"svelte": "^4.0.0 || ^5.0.0"
+	},
 	"workspaces": [
 		"packages/*"
 	],
@@ -18,7 +47,8 @@
 		"test": "npm run check && npm run test:e2e",
 		"changeset": "changeset",
 		"version-packages": "changeset version",
-		"release": "changeset publish"
+		"release": "changeset publish",
+		"prepack": "npm -w @aureuma/blogkit run build"
 	},
 	"devDependencies": {
 		"@changesets/changelog-github": "^0.5.2",
@@ -47,9 +77,11 @@
 		"vite": "^7.3.1"
 	},
 	"dependencies": {
+		"esm-env": "^1.2.2",
 		"@fontsource/geist-mono": "^5.2.7",
 		"@fontsource/inter": "^5.2.8",
 		"gray-matter": "^4.0.3",
+		"marked": "^12.0.2",
 		"reading-time": "^1.5.0",
 		"zod": "^4.3.6"
 	},

package/packages/blogkit/CHANGELOG.md

@@ -4,3 +4,15 @@ All notable changes to this package will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [0.1.0] - 2026-02-22
+### Added
+- Added `createRawBlog` support for raw markdown module sources.
+- Added Viva frontmatter and author parser helpers:
+  - `parseVivaBlogFrontmatter`
+  - `parseVivaAuthorFrontmatter`
+  - `parseMarkdownAuthorMap`
+  - `parseVivaAuthorProfiles`
+- Added exported Viva-focused types for frontmatter and author profiles.
+
+### Changed
+- Expanded `@aureuma/svelta/server` exports to support Viva app migration without custom blog parsing code.

package/packages/blogkit/dist/index.d.ts

@@ -8,4 +8,4 @@ export { default as MorePosts } from './components/blog/MorePosts.svelte';
 export { default as ShareButtons } from './components/blog/ShareButtons.svelte';
 export { default as SummaryCard } from './components/blog/SummaryCard.svelte';
 export { default as TagTabs } from './components/blog/TagTabs.svelte';
-export type { BlogAuthor, BlogCategory, BlogPost, BlogPostFull } from './types/blog';
+export type { BlogAuthor, BlogCategory, BlogPost, BlogPostFull, BlogPostWithContent, BlogTag } from './types/blog';

package/packages/blogkit/dist/server/blog.d.ts

@@ -1,4 +1,4 @@
-import type { BlogAuthor, BlogCategory, BlogPost, BlogPostFull } from '../types/blog';
+import type { BlogAuthor, BlogCategory, BlogPost, BlogPostFull, BlogPostWithContent, BlogTag } from '../types/blog';
 import { z } from 'zod';
 declare const frontmatterSchema: z.ZodObject<{
     title: z.ZodString;
@@ -29,6 +29,54 @@ export type BlogCreateConfig = {
     categoryOrder?: string[];
     mapFrontmatter?: BlogFrontmatterAdapter;
 };
+export type MarkdownRenderer = (markdown: string) => string | Promise<string>;
+export type RawBlogCreateConfig = {
+    rawModules: Record<string, () => Promise<string>>;
+    getAuthor: (id: string) => BlogAuthor;
+    categoryOrder?: string[];
+    mapFrontmatter?: BlogFrontmatterAdapter;
+    renderMarkdown?: MarkdownRenderer;
+};
+export type VivaImageAsset = {
+    url: string;
+    alt: string;
+    width: number;
+    height: number;
+    credit: string;
+    source: string;
+};
+export type VivaSeoFields = {
+    title: string;
+    description: string;
+    keywords: string[];
+};
+export type VivaBlogFrontmatter = {
+    title: string;
+    description: string;
+    slug: string;
+    publishedAt: string;
+    updatedAt: string;
+    author: string;
+    tags: string[];
+    canonical: string;
+    ogImage: VivaImageAsset;
+    draft: boolean;
+    seo: VivaSeoFields;
+};
+export type VivaAuthorFrontmatter = {
+    name: string;
+    slug: string;
+    role: string;
+    bio: string;
+    interests: string[];
+    canonical: string;
+    avatar: VivaImageAsset;
+    seo: VivaSeoFields;
+};
+export type VivaAuthorProfile = VivaAuthorFrontmatter & {
+    html: string;
+    raw: string;
+};
 export declare function createBlog(config: BlogCreateConfig): {
     getAllPosts: () => Promise<BlogPost[]>;
     getAllPostsFull: () => Promise<BlogPostFull[]>;
@@ -36,4 +84,23 @@ export declare function createBlog(config: BlogCreateConfig): {
     getCategories: () => Promise<BlogCategory[]>;
     pickHero: (posts?: BlogPost[]) => Promise<BlogPost>;
 };
+export declare function parseVivaBlogFrontmatter(data: unknown): VivaBlogFrontmatter;
+export declare function parseVivaAuthorFrontmatter(data: unknown): VivaAuthorFrontmatter;
+export declare function parseMarkdownAuthorMap(rawModules: Record<string, string>, fallbackAvatar?: string): Map<string, BlogAuthor>;
+export declare function parseVivaAuthorProfiles(rawModules: Record<string, string>, renderMarkdown?: MarkdownRenderer): Promise<VivaAuthorProfile[]>;
+export declare function createRawBlog(config: RawBlogCreateConfig): {
+    getAllPosts: () => Promise<BlogPost[]>;
+    getAllPostsWithContent: () => Promise<BlogPostWithContent[]>;
+    getPostBySlug: (slug: string) => Promise<BlogPostWithContent | null>;
+    getCategories: () => Promise<BlogCategory[]>;
+    pickHero: (posts?: BlogPost[]) => Promise<BlogPost>;
+    getAllTags: () => Promise<BlogTag[]>;
+    getPostsByTag: (tagSlug: string) => Promise<BlogPostWithContent[]>;
+    getPostsByAuthor: (authorId: string) => Promise<BlogPostWithContent[]>;
+    getAdjacentPosts: (slug: string) => Promise<{
+        previous: BlogPostWithContent | null;
+        next: BlogPostWithContent | null;
+    }>;
+    getRelatedPosts: (slug: string, limit?: number) => Promise<BlogPostWithContent[]>;
+};
 export {};

package/packages/blogkit/dist/server/blog.js

@@ -1,5 +1,6 @@
 import { DEV } from 'esm-env';
 import matter from 'gray-matter';
+import { marked } from 'marked';
 import readingTime from 'reading-time';
 import { z } from 'zod';
 const frontmatterSchema = z.object({
@@ -23,6 +24,46 @@ const DEFAULT_CATEGORY_ORDER = [
     'design',
     'best-practices'
 ];
+const vivaImageAssetSchema = z.object({
+    url: z.string(),
+    alt: z.string(),
+    width: z.number(),
+    height: z.number(),
+    credit: z.string(),
+    source: z.string()
+});
+const vivaSeoFieldsSchema = z.object({
+    title: z.string(),
+    description: z.string(),
+    keywords: z.array(z.string())
+});
+const vivaDateField = z
+    .union([z.string(), z.date()])
+    .transform((value) => (value instanceof Date ? value.toISOString() : value));
+const vivaBlogFrontmatterSchema = z.object({
+    title: z.string(),
+    description: z.string(),
+    slug: z.string(),
+    publishedAt: vivaDateField,
+    updatedAt: vivaDateField,
+    author: z.string(),
+    tags: z.array(z.string()),
+    canonical: z.string(),
+    ogImage: vivaImageAssetSchema,
+    draft: z.boolean().optional().default(false),
+    seo: vivaSeoFieldsSchema
+});
+const vivaAuthorFrontmatterSchema = z.object({
+    name: z.string(),
+    slug: z.string(),
+    role: z.string(),
+    bio: z.string(),
+    interests: z.array(z.string()),
+    canonical: z.string(),
+    avatar: vivaImageAssetSchema,
+    seo: vivaSeoFieldsSchema
+});
+const frontmatterOnlySchema = /^---\s*[\r\n]+([\s\S]*?)\r?\n---\s*[\r\n]+/;
 function slugify(input) {
     return input
         .toLowerCase()
@@ -220,3 +261,210 @@ export function createBlog(config) {
     }
     return { getAllPosts, getAllPostsFull, getPostBySlug, getCategories, pickHero };
 }
+export function parseVivaBlogFrontmatter(data) {
+    return vivaBlogFrontmatterSchema.parse(data);
+}
+export function parseVivaAuthorFrontmatter(data) {
+    return vivaAuthorFrontmatterSchema.parse(data);
+}
+function extractFrontmatter(raw) {
+    const match = raw.match(frontmatterOnlySchema);
+    if (!match)
+        return {};
+    return matter(raw).data;
+}
+export function parseMarkdownAuthorMap(rawModules, fallbackAvatar = '/favicon.ico') {
+    const map = new Map();
+    for (const [path, raw] of Object.entries(rawModules)) {
+        const defaultSlug = path.split('/').pop()?.replace(/\.md(?:\?.*)?$/, '') || '';
+        const data = extractFrontmatter(raw);
+        const record = (typeof data === 'object' && data ? data : {});
+        const id = typeof record.slug === 'string' && record.slug.length > 0 ? record.slug : defaultSlug;
+        if (!id)
+            continue;
+        const name = typeof record.name === 'string' && record.name.length > 0 ? record.name : id;
+        const title = typeof record.role === 'string' && record.role.length > 0 ? record.role : 'Contributor';
+        const avatarRecord = record.avatar && typeof record.avatar === 'object'
+            ? record.avatar
+            : null;
+        const avatar = avatarRecord && typeof avatarRecord.url === 'string' ? avatarRecord.url : fallbackAvatar;
+        map.set(id, { id, name, title, avatar });
+    }
+    return map;
+}
+export async function parseVivaAuthorProfiles(rawModules, renderMarkdown = defaultRenderMarkdown) {
+    const profiles = [];
+    for (const [path, raw] of Object.entries(rawModules)) {
+        const { data, content } = matter(raw);
+        const parsed = parseVivaAuthorFrontmatter(data);
+        const html = await renderMarkdown(content);
+        profiles.push({
+            ...parsed,
+            html,
+            raw: content
+        });
+    }
+    profiles.sort((a, b) => a.name.localeCompare(b.name));
+    return profiles;
+}
+const defaultRenderMarkdown = (markdown) => String(marked.parse(markdown));
+function toBlogTag(name) {
+    return {
+        name,
+        slug: slugify(name)
+    };
+}
+export function createRawBlog(config) {
+    const categoryOrder = config.categoryOrder ?? DEFAULT_CATEGORY_ORDER;
+    const renderMarkdown = config.renderMarkdown ?? defaultRenderMarkdown;
+    let cachedContentIndex = null;
+    async function buildContentIndex() {
+        if (!DEV && cachedContentIndex)
+            return cachedContentIndex;
+        const posts = [];
+        const paths = Object.keys(config.rawModules).sort();
+        for (const path of paths) {
+            const file = path.split('/').pop();
+            const slug = file?.replace(/\.md(?:\?.*)?$/, '');
+            if (!slug)
+                continue;
+            const rawFn = config.rawModules[path];
+            if (!rawFn)
+                continue;
+            const raw = await rawFn();
+            const { data, content } = matter(raw);
+            const metadata = config.mapFrontmatter
+                ? config.mapFrontmatter({ data, content, slug, path })
+                : frontmatterSchema.parse(data);
+            if (metadata.draft)
+                continue;
+            const dateObj = parseISODate(metadata.date);
+            const rt = minutesToLabels(readingTime(content).minutes);
+            const category = normalizeCategory(metadata.category);
+            const excerpt = metadata.excerpt?.trim() || excerptFromContent(content);
+            const rendered = await renderMarkdown(content);
+            posts.push({
+                slug,
+                title: metadata.title.trim(),
+                excerpt,
+                category,
+                tags: metadata.tags ?? [],
+                author: config.getAuthor(metadata.author),
+                authorId: metadata.author,
+                date: metadata.date,
+                dateLong: fmtLong.format(dateObj),
+                dateShort: fmtShort.format(dateObj),
+                readingMinutes: rt.minutes,
+                readingTimeShort: rt.short,
+                readingTimeLong: rt.long,
+                cover: metadata.cover,
+                summaryAI: metadata.summaryAI,
+                featured: Boolean(metadata.featured),
+                html: rendered,
+                raw: content,
+                frontmatter: typeof data === 'object' && data ? data : {}
+            });
+        }
+        posts.sort((a, b) => parseISODate(b.date).getTime() - parseISODate(a.date).getTime());
+        if (!DEV)
+            cachedContentIndex = posts;
+        return posts;
+    }
+    function stripContent(post) {
+        const { html: _html, raw: _raw, authorId: _authorId, frontmatter: _frontmatter, ...meta } = post;
+        return meta;
+    }
+    async function getAllPosts() {
+        const posts = await buildContentIndex();
+        return posts.map(stripContent);
+    }
+    async function getAllPostsWithContent() {
+        return buildContentIndex();
+    }
+    async function getPostBySlug(slug) {
+        const posts = await buildContentIndex();
+        return posts.find((p) => p.slug === slug) ?? null;
+    }
+    async function getCategories() {
+        const posts = await getAllPosts();
+        const map = new Map();
+        for (const p of posts)
+            map.set(p.category.slug, p.category.label);
+        return Array.from(map.entries())
+            .map(([slug, label]) => ({ slug, label }))
+            .sort((a, b) => {
+            const ai = categoryOrder.indexOf(a.slug);
+            const bi = categoryOrder.indexOf(b.slug);
+            if (ai === -1 && bi === -1)
+                return a.label.localeCompare(b.label);
+            if (ai === -1)
+                return 1;
+            if (bi === -1)
+                return -1;
+            return ai - bi;
+        });
+    }
+    async function pickHero(posts) {
+        const list = posts ?? (await getAllPosts());
+        const featured = list.filter((p) => p.featured);
+        return (featured[0] ?? list[0]);
+    }
+    async function getAllTags() {
+        const posts = await buildContentIndex();
+        const map = new Map();
+        for (const post of posts) {
+            for (const tagName of post.tags) {
+                const tag = toBlogTag(tagName);
+                map.set(tag.slug, tag);
+            }
+        }
+        return Array.from(map.values()).sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async function getPostsByTag(tagSlug) {
+        const posts = await buildContentIndex();
+        return posts.filter((post) => post.tags.some((tagName) => slugify(tagName) === tagSlug));
+    }
+    async function getPostsByAuthor(authorId) {
+        const posts = await buildContentIndex();
+        return posts.filter((post) => post.authorId === authorId);
+    }
+    async function getAdjacentPosts(slug) {
+        const posts = await buildContentIndex();
+        const index = posts.findIndex((post) => post.slug === slug);
+        if (index === -1)
+            return { previous: null, next: null };
+        return {
+            previous: posts[index + 1] ?? null,
+            next: posts[index - 1] ?? null
+        };
+    }
+    async function getRelatedPosts(slug, limit = 3) {
+        const posts = await buildContentIndex();
+        const current = posts.find((post) => post.slug === slug);
+        if (!current)
+            return [];
+        const tagSet = new Set(current.tags.map((tag) => slugify(tag)));
+        return posts
+            .filter((post) => post.slug !== slug)
+            .map((post) => {
+            const overlap = post.tags.filter((tag) => tagSet.has(slugify(tag))).length;
+            return { post, overlap };
+        })
+            .filter((entry) => entry.overlap > 0)
+            .sort((a, b) => b.overlap - a.overlap)
+            .slice(0, limit)
+            .map((entry) => entry.post);
+    }
+    return {
+        getAllPosts,
+        getAllPostsWithContent,
+        getPostBySlug,
+        getCategories,
+        pickHero,
+        getAllTags,
+        getPostsByTag,
+        getPostsByAuthor,
+        getAdjacentPosts,
+        getRelatedPosts
+    };
+}

package/packages/blogkit/dist/server/index.d.ts

@@ -1 +1 @@
-export { createBlog, type BlogCreateConfig } from './blog';
+export { createBlog, createRawBlog, parseMarkdownAuthorMap, parseVivaAuthorFrontmatter, parseVivaAuthorProfiles, parseVivaBlogFrontmatter, type BlogCreateConfig, type RawBlogCreateConfig, type MarkdownRenderer, type VivaAuthorFrontmatter, type VivaAuthorProfile, type VivaBlogFrontmatter, type VivaImageAsset, type VivaSeoFields } from './blog';

package/packages/blogkit/dist/server/index.js

@@ -1 +1 @@
-export { createBlog } from './blog';
+export { createBlog, createRawBlog, parseMarkdownAuthorMap, parseVivaAuthorFrontmatter, parseVivaAuthorProfiles, parseVivaBlogFrontmatter } from './blog';

package/packages/blogkit/dist/types/blog.d.ts

@@ -29,3 +29,13 @@ export type BlogPost = {
 export type BlogPostFull = BlogPost & {
     component: ComponentType;
 };
+export type BlogTag = {
+    name: string;
+    slug: string;
+};
+export type BlogPostWithContent = BlogPost & {
+    html: string;
+    raw: string;
+    authorId: string;
+    frontmatter: Record<string, unknown>;
+};

package/.changeset/README.md

@@ -1,8 +0,0 @@
-# Changesets
-
-Hello and welcome! This folder has been automatically generated by `@changesets/cli`, a build tool that works
-with multi-package repos, or single-package repos to help you version and publish your code. You can
-find the full documentation for it [in our repository](https://github.com/changesets/changesets)
-
-We have a quick list of common questions to get you started engaging with this project in
-[our documentation](https://github.com/changesets/changesets/blob/main/docs/common-questions.md)

package/.changeset/config.json

@@ -1,14 +0,0 @@
-{
-  "$schema": "https://unpkg.com/@changesets/config@3.1.2/schema.json",
-  "changelog": [
-    "@changesets/changelog-github",
-    { "repo": "Aureuma/svelta" }
-  ],
-  "commit": false,
-  "fixed": [],
-  "linked": [],
-  "access": "public",
-  "baseBranch": "main",
-  "updateInternalDependencies": "patch",
-  "ignore": []
-}

package/.changeset/publish-blogkit.md

@@ -1,5 +0,0 @@
----
-"@aureuma/blogkit": patch
----
-
-Prepare @aureuma/blogkit for the first public npm release.

package/.github/workflows/release.yml

@@ -1,65 +0,0 @@
-name: Release
-
-on:
-  push:
-    branches: [main]
-
-permissions:
-  contents: write
-  pull-requests: write
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: npm
-          registry-url: https://registry.npmjs.org
-
-      - name: Install
-        run: npm ci
-
-      - name: Create Release PR or Publish
-        id: changesets
-        uses: changesets/action@v1
-        with:
-          publish: npm run release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-      - name: Tag Published Package
-        if: steps.changesets.outputs.published == 'true'
-        id: tag
-        run: |
-          TAG="$(node - <<'NODE'
-          const pkgs = JSON.parse(process.env.PUBLISHED_PACKAGES || '[]');
-          const blogkit = pkgs.find((p) => p.name && p.name.includes('blogkit'));
-          if (!blogkit) process.exit(0);
-          process.stdout.write(`${blogkit.name}@${blogkit.version}`);
-          NODE
-          )"
-
-          if [ -z "$TAG" ]; then
-            echo "No published blogkit package found; skipping tag."
-            exit 0
-          fi
-
-          echo "tag=$TAG" >> "$GITHUB_OUTPUT"
-          git tag "$TAG"
-          git push origin "$TAG"
-        env:
-          PUBLISHED_PACKAGES: ${{ steps.changesets.outputs.publishedPackages }}
-
-      - name: GitHub Release
-        if: steps.changesets.outputs.published == 'true' && steps.tag.outputs.tag != ''
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: ${{ steps.tag.outputs.tag }}
-          generate_release_notes: true