@ewanc26/svelte-standard-site 0.2.0

package/dist/utils/at-uri.js

@@ -0,0 +1,71 @@
+/**
+ * AT URI parsing and conversion utilities
+ */
+/**
+ * Parse an AT URI into its components
+ * @param atUri - AT URI in format: at://did:plc:xxx/collection/rkey
+ * @returns Parsed components or null if invalid
+ */
+export function parseAtUri(atUri) {
+    if (!atUri.startsWith('at://'))
+        return null;
+    const withoutProtocol = atUri.slice(5); // Remove "at://"
+    const parts = withoutProtocol.split('/');
+    if (parts.length !== 3)
+        return null;
+    const [did, collection, rkey] = parts;
+    if (!did.startsWith('did:') || !collection || !rkey)
+        return null;
+    return { did, collection, rkey };
+}
+/**
+ * Convert AT URI to HTTPS URL for com.atproto.repo.getRecord
+ * @param atUri - AT URI in format: at://did:plc:xxx/collection/rkey
+ * @param pdsEndpoint - PDS endpoint (e.g., "https://cortinarius.us-west.host.bsky.network")
+ * @returns HTTPS URL for getRecord XRPC call
+ */
+export function atUriToHttps(atUri, pdsEndpoint) {
+    const parsed = parseAtUri(atUri);
+    if (!parsed)
+        return null;
+    // Ensure PDS endpoint doesn't have trailing slash
+    const pds = pdsEndpoint.replace(/\/$/, '');
+    return `${pds}/xrpc/com.atproto.repo.getRecord?repo=${encodeURIComponent(parsed.did)}&collection=${encodeURIComponent(parsed.collection)}&rkey=${encodeURIComponent(parsed.rkey)}`;
+}
+/**
+ * Construct an AT URI from components
+ * @param did - DID of the repository
+ * @param collection - Collection name
+ * @param rkey - Record key
+ * @returns AT URI string
+ */
+export function buildAtUri(did, collection, rkey) {
+    return `at://${did}/${collection}/${rkey}`;
+}
+/**
+ * Extract rkey from an AT URI
+ * @param atUri - AT URI
+ * @returns rkey or null if invalid
+ */
+export function extractRkey(atUri) {
+    const parsed = parseAtUri(atUri);
+    return parsed?.rkey ?? null;
+}
+/**
+ * Validate if string is a valid AT URI
+ * @param uri - String to validate
+ * @returns true if valid AT URI
+ */
+export function isAtUri(uri) {
+    return parseAtUri(uri) !== null;
+}
+/**
+ * Convert DID to PDS hostname format
+ * @param did - DID to convert
+ * @returns PDS hostname or null if unable to derive
+ */
+export function didToPdsHostname(did) {
+    // This is a simplified version - real implementation should use DID resolution
+    // For now, we'll return null and rely on explicit PDS configuration
+    return null;
+}

package/dist/utils/cache.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Simple in-memory cache with TTL support
+ */
+declare class Cache {
+    private store;
+    private defaultTTL;
+    get<T>(key: string): T | null;
+    set<T>(key: string, value: T, ttl?: number): void;
+    delete(key: string): void;
+    clear(): void;
+    setDefaultTTL(ttl: number): void;
+}
+export declare const cache: Cache;
+export {};

package/dist/utils/cache.js

@@ -0,0 +1,33 @@
+/**
+ * Simple in-memory cache with TTL support
+ */
+class Cache {
+    store = new Map();
+    defaultTTL = 5 * 60 * 1000; // 5 minutes
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return null;
+        if (Date.now() > entry.expires) {
+            this.store.delete(key);
+            return null;
+        }
+        return entry.value;
+    }
+    set(key, value, ttl) {
+        this.store.set(key, {
+            value,
+            expires: Date.now() + (ttl ?? this.defaultTTL)
+        });
+    }
+    delete(key) {
+        this.store.delete(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+    setDefaultTTL(ttl) {
+        this.defaultTTL = ttl;
+    }
+}
+export const cache = new Cache();

package/dist/utils/comments.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Comments utilities for fetching Bluesky replies
+ *
+ * Fetches threaded replies from Bluesky to display as comments on your blog.
+ *
+ * @example
+ * ```ts
+ * import { fetchComments } from 'svelte-standard-site/comments';
+ *
+ * const comments = await fetchComments({
+ *   bskyPostUri: 'at://did:plc:xxx/app.bsky.feed.post/abc123',
+ *   canonicalUrl: 'https://yourblog.com/posts/my-post',
+ *   maxDepth: 3,
+ * });
+ * ```
+ */
+export interface CommentAuthor {
+    did: string;
+    handle: string;
+    displayName?: string;
+    avatar?: string;
+}
+export interface Comment {
+    uri: string;
+    cid: string;
+    author: CommentAuthor;
+    text: string;
+    createdAt: string;
+    likeCount: number;
+    replyCount: number;
+    replies?: Comment[];
+    depth: number;
+}
+export interface FetchCommentsOptions {
+    /** AT-URI of the announcement post (e.g., at://did:plc:xxx/app.bsky.feed.post/abc123) */
+    bskyPostUri: string;
+    /** Optional canonical URL to search for mentions */
+    canonicalUrl?: string;
+    /** Maximum depth for nested replies (default: 3) */
+    maxDepth?: number;
+    /** Optional fetch function for SSR */
+    fetchFn?: typeof fetch;
+}
+/**
+ * Fetch comments for a blog post
+ *
+ * @param options - Configuration options
+ * @returns Array of top-level comments with nested replies
+ */
+export declare function fetchComments(options: FetchCommentsOptions): Promise<Comment[]>;
+/**
+ * Search for mentions of a URL and fetch those threads as comments
+ *
+ * This is useful if people share your blog post on Bluesky without
+ * replying to a specific announcement post.
+ */
+export declare function fetchMentionComments(canonicalUrl: string, maxDepth?: number): Promise<Comment[]>;
+/**
+ * Format a relative time string (e.g., "2 hours ago")
+ */
+export declare function formatRelativeTime(dateString: string): string;

package/dist/utils/comments.js

@@ -0,0 +1,159 @@
+/**
+ * Comments utilities for fetching Bluesky replies
+ *
+ * Fetches threaded replies from Bluesky to display as comments on your blog.
+ *
+ * @example
+ * ```ts
+ * import { fetchComments } from 'svelte-standard-site/comments';
+ *
+ * const comments = await fetchComments({
+ *   bskyPostUri: 'at://did:plc:xxx/app.bsky.feed.post/abc123',
+ *   canonicalUrl: 'https://yourblog.com/posts/my-post',
+ *   maxDepth: 3,
+ * });
+ * ```
+ */
+import { AtpAgent } from '@atproto/api';
+/**
+ * Parse an AT-URI to extract components
+ */
+function parseAtUri(uri) {
+    const match = uri.match(/^at:\/\/([^/]+)\/([^/]+)\/(.+)$/);
+    if (!match)
+        return null;
+    return {
+        did: match[1],
+        collection: match[2],
+        rkey: match[3]
+    };
+}
+/**
+ * Fetch a single thread of replies
+ */
+async function fetchThread(agent, uri, maxDepth, currentDepth = 0) {
+    try {
+        const response = await agent.getPostThread({
+            uri,
+            depth: maxDepth - currentDepth,
+            parentHeight: 0
+        });
+        const thread = response.data.thread;
+        if (thread.$type !== 'app.bsky.feed.defs#threadViewPost') {
+            return null;
+        }
+        const post = thread.post;
+        // Build comment object
+        const comment = {
+            uri: post.uri,
+            cid: post.cid,
+            author: {
+                did: post.author.did,
+                handle: post.author.handle,
+                displayName: post.author.displayName,
+                avatar: post.author.avatar
+            },
+            text: post.record?.text || '',
+            createdAt: post.indexedAt,
+            likeCount: post.likeCount || 0,
+            replyCount: post.replyCount || 0,
+            depth: currentDepth,
+            replies: []
+        };
+        // Process replies if within depth limit
+        if (thread.replies && currentDepth < maxDepth) {
+            for (const reply of thread.replies) {
+                if (reply.$type === 'app.bsky.feed.defs#threadViewPost') {
+                    const replyComment = await fetchThread(agent, reply.post.uri, maxDepth, currentDepth + 1);
+                    if (replyComment) {
+                        comment.replies.push(replyComment);
+                    }
+                }
+            }
+        }
+        return comment;
+    }
+    catch (error) {
+        console.error(`Failed to fetch thread for ${uri}:`, error);
+        return null;
+    }
+}
+/**
+ * Fetch comments for a blog post
+ *
+ * @param options - Configuration options
+ * @returns Array of top-level comments with nested replies
+ */
+export async function fetchComments(options) {
+    const { bskyPostUri, canonicalUrl, maxDepth = 3 } = options;
+    // Parse the post URI
+    const parsed = parseAtUri(bskyPostUri);
+    if (!parsed) {
+        console.error('Invalid AT-URI:', bskyPostUri);
+        return [];
+    }
+    try {
+        // Create agent
+        const agent = new AtpAgent({ service: 'https://public.api.bsky.app' });
+        // Fetch the main thread
+        const mainComment = await fetchThread(agent, bskyPostUri, maxDepth, 0);
+        if (!mainComment || !mainComment.replies) {
+            return [];
+        }
+        // Return only the replies (not the original post)
+        return mainComment.replies;
+    }
+    catch (error) {
+        console.error('Failed to fetch comments:', error);
+        return [];
+    }
+}
+/**
+ * Search for mentions of a URL and fetch those threads as comments
+ *
+ * This is useful if people share your blog post on Bluesky without
+ * replying to a specific announcement post.
+ */
+export async function fetchMentionComments(canonicalUrl, maxDepth = 3) {
+    try {
+        const agent = new AtpAgent({ service: 'https://public.api.bsky.app' });
+        // Search for posts mentioning the URL
+        const searchResponse = await agent.app.bsky.feed.searchPosts({
+            q: canonicalUrl,
+            limit: 25
+        });
+        const comments = [];
+        for (const post of searchResponse.data.posts) {
+            const comment = await fetchThread(agent, post.uri, maxDepth, 0);
+            if (comment) {
+                comments.push(comment);
+            }
+        }
+        return comments;
+    }
+    catch (error) {
+        console.error('Failed to fetch mention comments:', error);
+        return [];
+    }
+}
+/**
+ * Format a relative time string (e.g., "2 hours ago")
+ */
+export function formatRelativeTime(dateString) {
+    const date = new Date(dateString);
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffSecs = Math.floor(diffMs / 1000);
+    const diffMins = Math.floor(diffSecs / 60);
+    const diffHours = Math.floor(diffMins / 60);
+    const diffDays = Math.floor(diffHours / 24);
+    if (diffSecs < 60)
+        return 'just now';
+    if (diffMins < 60)
+        return `${diffMins} minute${diffMins === 1 ? '' : 's'} ago`;
+    if (diffHours < 24)
+        return `${diffHours} hour${diffHours === 1 ? '' : 's'} ago`;
+    if (diffDays < 7)
+        return `${diffDays} day${diffDays === 1 ? '' : 's'} ago`;
+    return date.toLocaleDateString();
+}

package/dist/utils/content.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Content transformation utilities for standard.site
+ *
+ * Converts blog post content into formats suitable for ATProto:
+ * - Strips markdown to plain text for `textContent` (search/indexing)
+ * - Converts custom sidenotes to standard markdown
+ * - Resolves relative links to absolute URLs
+ *
+ * @example
+ * ```ts
+ * import { transformContent, stripToPlainText } from 'svelte-standard-site/content';
+ *
+ * const result = transformContent(markdown, {
+ *   baseUrl: 'https://yourblog.com',
+ * });
+ *
+ * // result.markdown - cleaned markdown for ATProto
+ * // result.textContent - plain text for search
+ * ```
+ */
+export interface TransformOptions {
+    /** Base URL of your site (e.g., 'https://yourblog.com') */
+    baseUrl: string;
+    /** Optional path to the current post (e.g., '/blog/my-post') */
+    postPath?: string;
+}
+export interface TransformResult {
+    /** Transformed markdown suitable for ATProto */
+    markdown: string;
+    /** Plain text version for textContent field */
+    textContent: string;
+    /** Word count */
+    wordCount: number;
+    /** Estimated reading time in minutes */
+    readingTime: number;
+}
+/**
+ * Convert HTML sidenotes to markdown blockquotes
+ *
+ * Transforms:
+ * ```html
+ * <div class="sidenote sidenote--tip">
+ *   <span class="sidenote-label">Tip</span>
+ *   <p>Content here</p>
+ * </div>
+ * ```
+ *
+ * Into:
+ * ```markdown
+ * > **Tip:** Content here
+ * ```
+ */
+export declare function convertSidenotes(markdown: string): string;
+/**
+ * Convert HTML sidenotes (multi-paragraph) to markdown
+ * Handles more complex sidenote structures
+ */
+export declare function convertComplexSidenotes(markdown: string): string;
+/**
+ * Resolve relative URLs to absolute URLs
+ *
+ * Converts:
+ * - `[Link](/page)` → `[Link](https://example.com/page)`
+ * - `![Image](/img.png)` → `![Image](https://example.com/img.png)`
+ */
+export declare function resolveRelativeLinks(markdown: string, baseUrl: string): string;
+/**
+ * Strip markdown to plain text for indexing/search
+ *
+ * Removes:
+ * - Markdown formatting (**, *, #, etc.)
+ * - Links (keeps link text)
+ * - Images
+ * - Code blocks
+ * - HTML tags
+ */
+export declare function stripToPlainText(markdown: string): string;
+/**
+ * Calculate word count from text
+ */
+export declare function countWords(text: string): number;
+/**
+ * Calculate reading time in minutes (assuming 200 words per minute)
+ */
+export declare function calculateReadingTime(wordCount: number, wordsPerMinute?: number): number;
+/**
+ * Full content transformation pipeline
+ *
+ * Takes raw markdown (with HTML sidenotes) and produces:
+ * - Clean markdown suitable for ATProto platforms
+ * - Plain text for search/indexing
+ * - Metadata (word count, reading time)
+ */
+export declare function transformContent(rawMarkdown: string, options: TransformOptions): TransformResult;

package/dist/utils/content.js

@@ -0,0 +1,178 @@
+/**
+ * Content transformation utilities for standard.site
+ *
+ * Converts blog post content into formats suitable for ATProto:
+ * - Strips markdown to plain text for `textContent` (search/indexing)
+ * - Converts custom sidenotes to standard markdown
+ * - Resolves relative links to absolute URLs
+ *
+ * @example
+ * ```ts
+ * import { transformContent, stripToPlainText } from 'svelte-standard-site/content';
+ *
+ * const result = transformContent(markdown, {
+ *   baseUrl: 'https://yourblog.com',
+ * });
+ *
+ * // result.markdown - cleaned markdown for ATProto
+ * // result.textContent - plain text for search
+ * ```
+ */
+/**
+ * Convert HTML sidenotes to markdown blockquotes
+ *
+ * Transforms:
+ * ```html
+ * <div class="sidenote sidenote--tip">
+ *   <span class="sidenote-label">Tip</span>
+ *   <p>Content here</p>
+ * </div>
+ * ```
+ *
+ * Into:
+ * ```markdown
+ * > **Tip:** Content here
+ * ```
+ */
+export function convertSidenotes(markdown) {
+    // Match sidenote divs with various formats
+    const sidenoteRegex = /<div\s+class="sidenote(?:\s+sidenote--(warning|tip))?">\s*<span\s+class="sidenote-label">([^<]+)<\/span>\s*<p>([^<]+)<\/p>\s*<\/div>/gi;
+    return markdown.replace(sidenoteRegex, (_, type, label, content) => {
+        // Clean up the content
+        const cleanContent = content.trim();
+        const cleanLabel = label.trim();
+        // Convert to blockquote with label
+        return `\n> **${cleanLabel}:** ${cleanContent}\n`;
+    });
+}
+/**
+ * Convert HTML sidenotes (multi-paragraph) to markdown
+ * Handles more complex sidenote structures
+ */
+export function convertComplexSidenotes(markdown) {
+    // First pass: simple sidenotes
+    let result = convertSidenotes(markdown);
+    // Second pass: sidenotes with multiple paragraphs or nested content
+    const complexSidenoteRegex = /<div\s+class="sidenote[^"]*">([\s\S]*?)<\/div>/gi;
+    result = result.replace(complexSidenoteRegex, (match, innerContent) => {
+        // Extract label if present
+        const labelMatch = innerContent.match(/<span\s+class="sidenote-label">([^<]+)<\/span>/i);
+        const label = labelMatch ? labelMatch[1].trim() : 'Note';
+        // Remove the label span
+        let content = innerContent.replace(/<span\s+class="sidenote-label">[^<]+<\/span>/gi, '');
+        // Convert remaining HTML to plain text with basic formatting
+        content = content
+            .replace(/<p>/gi, '')
+            .replace(/<\/p>/gi, '\n')
+            .replace(/<strong>/gi, '**')
+            .replace(/<\/strong>/gi, '**')
+            .replace(/<em>/gi, '*')
+            .replace(/<\/em>/gi, '*')
+            .replace(/<a\s+href="([^"]+)"[^>]*>([^<]+)<\/a>/gi, '[$2]($1)')
+            .replace(/<[^>]+>/g, '') // Remove any remaining HTML tags
+            .trim();
+        // Format as blockquote
+        const lines = content.split('\n').filter((line) => line.trim());
+        const quotedLines = lines.map((line, i) => i === 0 ? `> **${label}:** ${line}` : `> ${line}`);
+        return '\n' + quotedLines.join('\n') + '\n';
+    });
+    return result;
+}
+/**
+ * Resolve relative URLs to absolute URLs
+ *
+ * Converts:
+ * - `[Link](/page)` → `[Link](https://example.com/page)`
+ * - `![Image](/img.png)` → `![Image](https://example.com/img.png)`
+ */
+export function resolveRelativeLinks(markdown, baseUrl) {
+    const cleanBaseUrl = baseUrl.replace(/\/$/, '');
+    // Match markdown links and images with relative URLs
+    // [text](/path) or ![alt](/path)
+    const linkRegex = /(!?\[[^\]]*\])\((?!https?:\/\/|mailto:|#)([^)]+)\)/g;
+    return markdown.replace(linkRegex, (_, prefix, path) => {
+        // Ensure path starts with /
+        const absolutePath = path.startsWith('/') ? path : `/${path}`;
+        return `${prefix}(${cleanBaseUrl}${absolutePath})`;
+    });
+}
+/**
+ * Strip markdown to plain text for indexing/search
+ *
+ * Removes:
+ * - Markdown formatting (**, *, #, etc.)
+ * - Links (keeps link text)
+ * - Images
+ * - Code blocks
+ * - HTML tags
+ */
+export function stripToPlainText(markdown) {
+    let text = markdown;
+    // Remove code blocks first (preserve nothing)
+    text = text.replace(/```[\s\S]*?```/g, '');
+    text = text.replace(/`[^`]+`/g, '');
+    // Remove images
+    text = text.replace(/!\[[^\]]*\]\([^)]+\)/g, '');
+    // Convert links to just their text
+    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+    // Remove HTML tags
+    text = text.replace(/<[^>]+>/g, '');
+    // Remove heading markers
+    text = text.replace(/^#{1,6}\s+/gm, '');
+    // Remove bold/italic markers
+    text = text.replace(/\*\*([^*]+)\*\*/g, '$1');
+    text = text.replace(/\*([^*]+)\*/g, '$1');
+    text = text.replace(/__([^_]+)__/g, '$1');
+    text = text.replace(/_([^_]+)_/g, '$1');
+    // Remove blockquote markers
+    text = text.replace(/^>\s*/gm, '');
+    // Remove list markers
+    text = text.replace(/^[\s]*[-*+]\s+/gm, '');
+    text = text.replace(/^[\s]*\d+\.\s+/gm, '');
+    // Remove horizontal rules
+    text = text.replace(/^[-*_]{3,}$/gm, '');
+    // Collapse multiple newlines
+    text = text.replace(/\n{3,}/g, '\n\n');
+    // Trim whitespace
+    text = text.trim();
+    return text;
+}
+/**
+ * Calculate word count from text
+ */
+export function countWords(text) {
+    return text.split(/\s+/).filter((word) => word.length > 0).length;
+}
+/**
+ * Calculate reading time in minutes (assuming 200 words per minute)
+ */
+export function calculateReadingTime(wordCount, wordsPerMinute = 200) {
+    return Math.max(1, Math.ceil(wordCount / wordsPerMinute));
+}
+/**
+ * Full content transformation pipeline
+ *
+ * Takes raw markdown (with HTML sidenotes) and produces:
+ * - Clean markdown suitable for ATProto platforms
+ * - Plain text for search/indexing
+ * - Metadata (word count, reading time)
+ */
+export function transformContent(rawMarkdown, options) {
+    // Step 1: Convert sidenotes from HTML to markdown blockquotes
+    let markdown = convertComplexSidenotes(rawMarkdown);
+    // Step 2: Resolve relative links to absolute URLs
+    markdown = resolveRelativeLinks(markdown, options.baseUrl);
+    // Step 3: Clean up extra whitespace
+    markdown = markdown.replace(/\n{3,}/g, '\n\n').trim();
+    // Step 4: Generate plain text version
+    const textContent = stripToPlainText(markdown);
+    // Step 5: Calculate metadata
+    const wordCount = countWords(textContent);
+    const readingTime = calculateReadingTime(wordCount);
+    return {
+        markdown,
+        textContent,
+        wordCount,
+        readingTime
+    };
+}

package/dist/utils/document.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Extract rkey from AT URI
+ */
+export declare function extractRkey(uri: string): string | null;
+/**
+ * Get document slug (uses path if available, otherwise rkey)
+ */
+export declare function getDocumentSlug(document: {
+    uri: string;
+    value: {
+        path?: string;
+    };
+}): string;
+/**
+ * Get document canonical URL
+ */
+export declare function getDocumentUrl(document: {
+    value: {
+        site: string;
+        path?: string;
+    };
+    uri: string;
+}): string;

package/dist/utils/document.js

@@ -0,0 +1,33 @@
+/**
+ * Extract rkey from AT URI
+ */
+export function extractRkey(uri) {
+    const match = uri.match(/at:\/\/[^\/]+\/[^\/]+\/(.+)$/);
+    return match ? match[1] : null;
+}
+/**
+ * Get document slug (uses path if available, otherwise rkey)
+ */
+export function getDocumentSlug(document) {
+    if (document.value.path) {
+        // Remove leading slash if present
+        return document.value.path.replace(/^\//, '');
+    }
+    return extractRkey(document.uri) || '';
+}
+/**
+ * Get document canonical URL
+ */
+export function getDocumentUrl(document) {
+    const { site, path } = document.value;
+    // If site is an AT URI, we'll use our local route
+    if (site.startsWith('at://')) {
+        return `/documents/${getDocumentSlug(document)}`;
+    }
+    // If site is HTTPS and we have a path, combine them
+    if (path) {
+        return `${site.replace(/\/$/, '')}/${path.replace(/^\//, '')}`;
+    }
+    // Fallback to local route
+    return `/documents/${extractRkey(document.uri)}`;
+}