@ewanc26/svelte-standard-site 0.2.3 → 0.2.4

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 /**
- * Core types for site.standard.* lexicons
+ * Core types for site.standard.* and pub.leaflet.* lexicons
  */
 /**
  * AT Protocol blob reference
@@ -27,6 +27,28 @@ export interface RGBColor {
     g: number;
     b: number;
 }
+/**
+ * RGBA Color (with alpha)
+ */
+export interface RGBAColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+/**
+ * Color union (RGB or RGBA)
+ */
+export type Color = RGBColor | RGBAColor;
+/**
+ * Background image configuration
+ */
+export interface BackgroundImage {
+    $type?: 'pub.leaflet.theme.backgroundImage';
+    url: string;
+    opacity?: number;
+    blur?: number;
+}
 /**
  * Basic theme for publications
  */
@@ -37,6 +59,22 @@ export interface BasicTheme {
     accent: RGBColor;
     accentForeground: RGBColor;
 }
+/**
+ * Extended theme for publications (pub.leaflet.publication#theme)
+ */
+export interface ExtendedTheme {
+    $type?: 'pub.leaflet.theme';
+    backgroundColor?: Color;
+    pageBackground?: Color;
+    showPageBackground?: boolean;
+    primary?: Color;
+    accentBackground?: Color;
+    accentText?: Color;
+    headingFont?: string;
+    bodyFont?: string;
+    pageWidth?: number;
+    backgroundImage?: BackgroundImage;
+}
 /**
  * Publication preferences
  */
@@ -57,6 +95,7 @@ export interface Publication {
     icon?: string;
     description?: string;
     basicTheme?: BasicTheme;
+    theme?: ExtendedTheme;
     preferences?: PublicationPreferences;
 }
 /**
@@ -69,14 +108,366 @@ export interface Document {
     path?: string;
     description?: string;
     coverImage?: string;
-    content?: any;
+    content?: Content;
     textContent?: string;
     bskyPostRef?: StrongRef;
     tags?: string[];
     publishedAt: string;
     updatedAt?: string;
+    theme?: ExtendedTheme;
     preferences?: PublicationPreferences;
 }
+/**
+ * Byte slice for facet index
+ */
+export interface ByteSlice {
+    byteStart: number;
+    byteEnd: number;
+}
+/**
+ * Link facet feature
+ */
+export interface LinkFeature {
+    $type: 'pub.leaflet.richtext.facet#link';
+    uri: string;
+}
+/**
+ * DID Mention facet feature
+ */
+export interface DidMentionFeature {
+    $type: 'pub.leaflet.richtext.facet#didMention';
+    did: string;
+}
+/**
+ * AT URI Mention facet feature
+ */
+export interface AtMentionFeature {
+    $type: 'pub.leaflet.richtext.facet#atMention';
+    atURI: string;
+}
+/**
+ * Code facet feature (inline code)
+ */
+export interface CodeFeature {
+    $type: 'pub.leaflet.richtext.facet#code';
+}
+/**
+ * Highlight facet feature
+ */
+export interface HighlightFeature {
+    $type: 'pub.leaflet.richtext.facet#highlight';
+}
+/**
+ * Underline facet feature
+ */
+export interface UnderlineFeature {
+    $type: 'pub.leaflet.richtext.facet#underline';
+}
+/**
+ * Strikethrough facet feature
+ */
+export interface StrikethroughFeature {
+    $type: 'pub.leaflet.richtext.facet#strikethrough';
+}
+/**
+ * Bold facet feature
+ */
+export interface BoldFeature {
+    $type: 'pub.leaflet.richtext.facet#bold';
+}
+/**
+ * Italic facet feature
+ */
+export interface ItalicFeature {
+    $type: 'pub.leaflet.richtext.facet#italic';
+}
+/**
+ * ID facet feature (for anchor links)
+ */
+export interface IdFeature {
+    $type: 'pub.leaflet.richtext.facet#id';
+    id: string;
+}
+/**
+ * Footnote facet feature
+ */
+export interface FootnoteFeature {
+    $type: 'pub.leaflet.richtext.facet#footnote';
+    footnoteId: string;
+    contentPlaintext: string;
+    contentFacets?: Facet[];
+}
+/**
+ * Facet feature union
+ */
+export type FacetFeature = LinkFeature | DidMentionFeature | AtMentionFeature | CodeFeature | HighlightFeature | UnderlineFeature | StrikethroughFeature | BoldFeature | ItalicFeature | IdFeature | FootnoteFeature;
+/**
+ * Rich Text Facet
+ */
+export interface Facet {
+    index: ByteSlice;
+    features: FacetFeature[];
+}
+/**
+ * Text Block
+ */
+export interface TextBlock {
+    $type: 'pub.leaflet.blocks.text';
+    plaintext: string;
+    textSize?: 'default' | 'small' | 'large';
+    facets?: Facet[];
+}
+/**
+ * Header Block
+ */
+export interface HeaderBlock {
+    $type: 'pub.leaflet.blocks.header';
+    plaintext: string;
+    level?: number;
+    facets?: Facet[];
+}
+/**
+ * Blockquote Block
+ */
+export interface BlockquoteBlock {
+    $type: 'pub.leaflet.blocks.blockquote';
+    plaintext: string;
+    facets?: Facet[];
+}
+/**
+ * Image Block
+ */
+export interface ImageBlock {
+    $type: 'pub.leaflet.blocks.image';
+    image: AtProtoBlob;
+    alt?: string;
+    aspectRatio?: {
+        width: number;
+        height: number;
+    };
+}
+/**
+ * Code Block
+ */
+export interface CodeBlock {
+    $type: 'pub.leaflet.blocks.code';
+    code: string;
+    language?: string;
+    filename?: string;
+}
+/**
+ * Math Block
+ */
+export interface MathBlock {
+    $type: 'pub.leaflet.blocks.math';
+    tex: string;
+    display?: boolean;
+}
+/**
+ * Ordered List Item
+ */
+export interface OrderedListItem {
+    content?: TextBlock | HeaderBlock | ImageBlock;
+    checked?: boolean;
+    children?: OrderedListItem[];
+    unorderedListChildren?: UnorderedListBlock;
+}
+/**
+ * Ordered List Block
+ */
+export interface OrderedListBlock {
+    $type: 'pub.leaflet.blocks.orderedList';
+    children: OrderedListItem[];
+    startIndex?: number;
+}
+/**
+ * Unordered List Item
+ */
+export interface UnorderedListItem {
+    content?: TextBlock | HeaderBlock | ImageBlock;
+    children?: UnorderedListItem[];
+}
+/**
+ * Unordered List Block
+ */
+export interface UnorderedListBlock {
+    $type: 'pub.leaflet.blocks.unorderedList';
+    children: UnorderedListItem[];
+}
+/**
+ * Horizontal Rule Block
+ */
+export interface HorizontalRuleBlock {
+    $type: 'pub.leaflet.blocks.horizontalRule';
+}
+/**
+ * Iframe Block
+ */
+export interface IframeBlock {
+    $type: 'pub.leaflet.blocks.iframe';
+    src: string;
+    title?: string;
+    width?: number;
+    height?: number;
+}
+/**
+ * Website Embed Block
+ */
+export interface WebsiteBlock {
+    $type: 'pub.leaflet.blocks.website';
+    url: string;
+    title?: string;
+    description?: string;
+    image?: AtProtoBlob;
+}
+/**
+ * Button Block
+ */
+export interface ButtonBlock {
+    $type: 'pub.leaflet.blocks.button';
+    text: string;
+    href: string;
+    variant?: 'primary' | 'secondary' | 'outline';
+}
+/**
+ * Bluesky Post Block
+ */
+export interface BskyPostBlock {
+    $type: 'pub.leaflet.blocks.bskyPost';
+    uri: string;
+}
+/**
+ * Poll Block
+ */
+export interface PollBlock {
+    $type: 'pub.leaflet.blocks.poll';
+    question: string;
+    options: Array<{
+        text: string;
+        votes?: number;
+    }>;
+    endsAt?: string;
+}
+/**
+ * Page Block (internal page reference)
+ */
+export interface PageBlock {
+    $type: 'pub.leaflet.blocks.page';
+    pageId: string;
+}
+/**
+ * Block union type
+ */
+export type Block = TextBlock | HeaderBlock | BlockquoteBlock | ImageBlock | CodeBlock | MathBlock | OrderedListBlock | UnorderedListBlock | HorizontalRuleBlock | IframeBlock | WebsiteBlock | ButtonBlock | BskyPostBlock | PollBlock | PageBlock;
+/**
+ * Position for quotes
+ */
+export interface Position {
+    block: number[];
+    offset: number;
+}
+/**
+ * Quote reference
+ */
+export interface Quote {
+    start: Position;
+    end: Position;
+}
+/**
+ * Linear Document Page Block Wrapper
+ */
+export interface LinearDocumentBlockWrapper {
+    $type: 'pub.leaflet.pages.linearDocument#block';
+    block: Block;
+    alignment?: '#textAlignLeft' | '#textAlignCenter' | '#textAlignRight' | '#textAlignJustify';
+}
+/**
+ * Linear Document Page
+ */
+export interface LinearDocumentPage {
+    $type: 'pub.leaflet.pages.linearDocument';
+    id?: string;
+    blocks: LinearDocumentBlockWrapper[];
+    quote?: Quote;
+}
+/**
+ * Canvas Page Block Wrapper
+ */
+export interface CanvasBlockWrapper {
+    $type: 'pub.leaflet.pages.canvas#block';
+    block: Block;
+    x: number;
+    y: number;
+    width: number;
+    height?: number;
+    rotation?: number;
+}
+/**
+ * Canvas Page
+ */
+export interface CanvasPage {
+    $type: 'pub.leaflet.pages.canvas';
+    id?: string;
+    blocks: CanvasBlockWrapper[];
+    quote?: Quote;
+}
+/**
+ * Content (pub.leaflet.content)
+ */
+export interface Content {
+    $type: 'pub.leaflet.content';
+    pages: (LinearDocumentPage | CanvasPage)[];
+}
+/**
+ * Linear Document Quote (for comment attachments)
+ */
+export interface LinearDocumentQuote {
+    $type?: 'pub.leaflet.comment#linearDocumentQuote';
+    document: string;
+    quote?: Quote;
+}
+/**
+ * Comment Reply Reference
+ */
+export interface CommentReplyRef {
+    $type?: 'pub.leaflet.comment#replyRef';
+    parent: string;
+}
+/**
+ * Comment record
+ */
+export interface CommentRecord {
+    $type: 'pub.leaflet.comment';
+    subject: string;
+    plaintext: string;
+    createdAt: string;
+    reply?: CommentReplyRef;
+    facets?: Facet[];
+    onPage?: string;
+    attachment?: LinearDocumentQuote;
+}
+/**
+ * Recommend record
+ */
+export interface RecommendRecord {
+    $type: 'pub.leaflet.interactions.recommend';
+    subject: string;
+    createdAt: string;
+}
+/**
+ * Subscription record (site.standard.graph.subscription)
+ */
+export interface SubscriptionRecord {
+    $type: 'site.standard.graph.subscription';
+    publication: string;
+}
+/**
+ * Leaflet Subscription record (pub.leaflet.graph.subscription)
+ */
+export interface LeafletSubscriptionRecord {
+    $type: 'pub.leaflet.graph.subscription';
+    publication: string;
+}
 /**
  * AT Protocol record response
  */

package/dist/types.js

@@ -1,4 +1,4 @@
 /**
- * Core types for site.standard.* lexicons
+ * Core types for site.standard.* and pub.leaflet.* lexicons
  */
 export {};

package/dist/utils/native-comments.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Native Comments utilities for pub.leaflet.comment records
+ */
+import type { CommentRecord, Facet, LinearDocumentQuote } from '../types.js';
+/** Collection name for comments */
+export declare const COMMENTS_COLLECTION = "pub.leaflet.comment";
+/**
+ * Create a comment record
+ */
+export declare function createCommentRecord(params: {
+    subject: string;
+    plaintext: string;
+    reply?: {
+        parent: string;
+    };
+    facets?: Facet[];
+    onPage?: string;
+    attachment?: LinearDocumentQuote;
+}): CommentRecord;
+/**
+ * Parse a comment AT-URI to extract components
+ */
+export declare function parseCommentUri(uri: string): {
+    did: string;
+    collection: string;
+    rkey: string;
+} | null;
+/**
+ * Build a comment AT-URI
+ */
+export declare function buildCommentUri(did: string, rkey: string): string;
+/**
+ * Fetch comments for a document
+ */
+export declare function fetchComments(subject: string, service?: string): Promise<Array<CommentRecord & {
+    uri: string;
+    cid: string;
+    author: {
+        did: string;
+    };
+}>>;
+/**
+ * Organize comments into a threaded structure
+ */
+export declare function organizeCommentsIntoThreads(comments: Array<CommentRecord & {
+    uri: string;
+    cid: string;
+    author: {
+        did: string;
+    };
+}>): Array<CommentRecord & {
+    uri: string;
+    cid: string;
+    author: {
+        did: string;
+    };
+    replies: any[];
+}>;
+/**
+ * Count total comments in a thread
+ */
+export declare function countThreadComments(thread: {
+    replies: any[];
+}): number;
+/**
+ * Get quoted text from a document
+ */
+export declare function extractQuotedText(document: any, quote: LinearDocumentQuote['quote']): string | null;

package/dist/utils/native-comments.js

@@ -0,0 +1,149 @@
+/**
+ * Native Comments utilities for pub.leaflet.comment records
+ */
+/** Collection name for comments */
+export const COMMENTS_COLLECTION = 'pub.leaflet.comment';
+/**
+ * Create a comment record
+ */
+export function createCommentRecord(params) {
+    const record = {
+        $type: 'pub.leaflet.comment',
+        subject: params.subject,
+        plaintext: params.plaintext,
+        createdAt: new Date().toISOString()
+    };
+    if (params.reply) {
+        record.reply = {
+            $type: 'pub.leaflet.comment#replyRef',
+            parent: params.reply.parent
+        };
+    }
+    if (params.facets) {
+        record.facets = params.facets;
+    }
+    if (params.onPage) {
+        record.onPage = params.onPage;
+    }
+    if (params.attachment) {
+        record.attachment = {
+            $type: 'pub.leaflet.comment#linearDocumentQuote',
+            ...params.attachment
+        };
+    }
+    return record;
+}
+/**
+ * Parse a comment AT-URI to extract components
+ */
+export function parseCommentUri(uri) {
+    const match = uri.match(/^at:\/\/([^/]+)\/([^/]+)\/([^/]+)$/);
+    if (!match)
+        return null;
+    return {
+        did: match[1],
+        collection: match[2],
+        rkey: match[3]
+    };
+}
+/**
+ * Build a comment AT-URI
+ */
+export function buildCommentUri(did, rkey) {
+    return `at://${did}/${COMMENTS_COLLECTION}/${rkey}`;
+}
+/**
+ * Fetch comments for a document
+ */
+export async function fetchComments(subject, service = 'https://public.api.bsky.app') {
+    try {
+        const response = await fetch(`${service}/xrpc/com.atproto.repo.listRecords?collection=${COMMENTS_COLLECTION}&limit=100`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch comments: ${response.status}`);
+        }
+        const data = await response.json();
+        // Filter comments for this subject
+        const comments = data.records
+            ?.filter((record) => record.value?.subject === subject)
+            ?.map((record) => ({
+            ...record.value,
+            uri: record.uri,
+            cid: record.cid,
+            author: { did: record.uri.split('/')[2] }
+        })) ?? [];
+        return comments;
+    }
+    catch (error) {
+        console.error('Error fetching comments:', error);
+        return [];
+    }
+}
+/**
+ * Organize comments into a threaded structure
+ */
+export function organizeCommentsIntoThreads(comments) {
+    const byId = new Map();
+    const rootComments = [];
+    // First pass: create all comment objects
+    for (const comment of comments) {
+        byId.set(comment.uri, { ...comment, replies: [] });
+    }
+    // Second pass: organize into threads
+    for (const comment of comments) {
+        const node = byId.get(comment.uri);
+        if (!node)
+            continue;
+        if (comment.reply?.parent) {
+            const parent = byId.get(comment.reply.parent);
+            if (parent) {
+                parent.replies.push(node);
+            }
+            else {
+                // Parent not found, treat as root
+                rootComments.push(node);
+            }
+        }
+        else {
+            rootComments.push(node);
+        }
+    }
+    // Sort root comments by date (newest first)
+    rootComments.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    return rootComments;
+}
+/**
+ * Count total comments in a thread
+ */
+export function countThreadComments(thread) {
+    let count = 1;
+    for (const reply of thread.replies) {
+        count += countThreadComments(reply);
+    }
+    return count;
+}
+/**
+ * Get quoted text from a document
+ */
+export function extractQuotedText(document, quote) {
+    if (!quote || !document?.content?.pages)
+        return null;
+    // Find the linear document page
+    const page = document.content.pages.find((p) => quote.start.block.every((b, i) => b === p.id || i === 0));
+    if (!page)
+        return null;
+    // Extract text based on block indices
+    const blocks = page.blocks || [];
+    const startBlockIndex = quote.start.block[quote.start.block.length - 1];
+    const endBlockIndex = quote.end.block[quote.end.block.length - 1];
+    if (startBlockIndex === undefined || endBlockIndex === undefined)
+        return null;
+    // For simplicity, return the text from the first block
+    // In a real implementation, you'd handle multi-block quotes
+    const startBlock = blocks[startBlockIndex]?.block;
+    if (!startBlock)
+        return null;
+    if (startBlock.plaintext) {
+        return startBlock.plaintext.slice(quote.start.offset, quote.end.offset);
+    }
+    return null;
+}

package/dist/utils/theme-helpers.d.ts

@@ -1,4 +1,4 @@
-import type { BasicTheme } from '../types.js';
+import type { BasicTheme, ExtendedTheme, BackgroundImage } from '../types.js';
 /**
  * Generate color-mix CSS for theme colors with transparency
  */
@@ -28,7 +28,47 @@ export declare function getThemedAccent(hasTheme: boolean, opacity?: number): {
     color?: string;
     backgroundColor?: string;
 };
+/**
+ * Get theme-aware page background
+ */
+export declare function getThemedPageBackground(hasTheme: boolean, showPageBackground?: boolean): {
+    backgroundColor?: string;
+};
+/**
+ * Get background image styles
+ */
+export declare function getBackgroundImageStyles(bgImage: BackgroundImage | undefined): {
+    backgroundImage?: string;
+    backgroundSize?: string;
+    backgroundPosition?: string;
+};
+/**
+ * Get font styles from theme
+ */
+export declare function getFontStyles(theme: ExtendedTheme | undefined): {
+    fontFamily?: string;
+};
+/**
+ * Get heading font styles from theme
+ */
+export declare function getHeadingFontStyles(theme: ExtendedTheme | undefined): {
+    fontFamily?: string;
+};
+/**
+ * Get page width styles from theme
+ */
+export declare function getPageWidthStyles(theme: ExtendedTheme | undefined): {
+    maxWidth?: string;
+};
 /**
  * Convert BasicTheme to CSS custom properties
  */
 export declare function themeToCssVars(theme?: BasicTheme): Record<string, string>;
+/**
+ * Convert ExtendedTheme to CSS custom properties
+ */
+export declare function extendedThemeToCssVars(theme?: ExtendedTheme): Record<string, string>;
+/**
+ * Convert any theme to CSS custom properties
+ */
+export declare function anyThemeToCssVars(theme?: BasicTheme | ExtendedTheme): Record<string, string>;