@stonedeck/core 0.7.0

package/src/emitter.ts

@@ -0,0 +1,118 @@
+import { parseManifesto } from './parser/manifesto.js';
+import { parseSlides } from './parser/tokenizer.js';
+import { ThemeLoader } from './resolver/theme-loader.js';
+import { validateLayout, getLayout } from './layouts/validator.js';
+import { StoneDeckIR, Slide, SlotContent, ListItem, TableCell } from './models/ir.js';
+import { metricsCalculator } from './resolver/metrics.js';
+import { mapMarkdownLists } from './parser/list-mapper.js';
+import { mapMarkdownTable } from './parser/table-mapper.js';
+import { mapMarkdownImage } from './parser/image-mapper.js';
+import * as path from 'path';
+
+/**
+ * Emitter orchestrates the parsing and theme resolution to produce the final IR.
+ */
+export function emitIR(content: string, filePath: string, themeOverride?: string): StoneDeckIR {
+    const basePath = path.dirname(filePath);
+    const globalWarnings: string[] = [];
+
+    // 1. Parse Manifesto
+    const { manifesto, remainingContent } = parseManifesto(content);
+
+    // 2. Parse Slides
+    const slides = parseSlides(remainingContent);
+
+    // 4. Resolve Temas e Validar Layouts
+    const themeToLoad = themeOverride || manifesto.theme;
+    const theme = ThemeLoader.load(themeToLoad, basePath);
+
+    const resolvedSlides = slides.map((slide, slideIdx) => {
+        // Validate Layout
+        const validation = validateLayout(slide.layout_id, slide.slots.length);
+        const warnings: string[] = [];
+        if (!validation.valid) {
+            warnings.push(validation.error!);
+        }
+
+        const layout = getLayout(slide.layout_id, slide.slots.length);
+        // Merge Theme Defaults
+        const defaults = theme.defaults || {};
+        const mergedStyle = { ...defaults, ...slide.style };
+
+        // Resolve Style with Theme
+        const resolvedStyle = ThemeLoader.resolveStyle(mergedStyle, theme);
+
+        // Process Slots (List, Table, Image detection)
+        const processedSlots: SlotContent[] = slide.slots.map(slot => {
+            if (slot.type === 'markdown') {
+                // Try Table
+                const tableRows = mapMarkdownTable(slot.raw);
+                if (tableRows) return { type: 'table', rows: tableRows };
+
+                // Try Image
+                const img = mapMarkdownImage(slot.raw);
+                if (img) return { type: 'image', src: img.src, ...(img.alt ? { alt: img.alt } : {}) } as SlotContent;
+
+                // Try List - but only convert if ALL content is list items
+                const listItems = mapMarkdownLists(slot.raw);
+                if (listItems.length > 0) {
+                    // Count non-empty, non-list lines
+                    const lines = slot.raw.split(/\r?\n/).filter(l => l.trim().length > 0);
+                    const hasOnlyListItems = lines.every(line => {
+                        // Check if line matches list pattern
+                        return /^\s*([-*]|\d+\.)\s+/.test(line);
+                    });
+
+                    if (hasOnlyListItems) {
+                        return { type: 'list', items: listItems };
+                    }
+                }
+            }
+            return slot;
+        });
+
+        // Calculate Metrics and Overflow
+        const heights: number[] = [];
+        if (layout) {
+            processedSlots.forEach((slot, slotIdx) => {
+                const slotDef = layout.slots[slotIdx];
+                if (slotDef) {
+                    let contentToMeasure = '';
+                    if (slot.type === 'list') {
+                        contentToMeasure = slot.items.map((i: ListItem) => i.text).join('\n');
+                    } else if (slot.type === 'markdown') {
+                        contentToMeasure = slot.raw;
+                    } else if (slot.type === 'table') {
+                        contentToMeasure = slot.rows.map((r: TableCell[]) => r.map((c: TableCell) => c.text).join(' ')).join('\n');
+                    } else if (slot.type === 'image') {
+                        contentToMeasure = slot.alt || slot.src;
+                    }
+
+                    const estimatedHeight = metricsCalculator.estimateMarkdownHeight(contentToMeasure, resolvedStyle, slotDef.width);
+                    heights.push(estimatedHeight);
+
+                    if (estimatedHeight > slotDef.height) {
+                        warnings.push(`Overflow Warning: Content in slot "${slotDef.id}" (slide ${slideIdx + 1}) exceeds defined height (${estimatedHeight.toFixed(1)}pt > ${slotDef.height}pt)`);
+                    }
+                }
+            });
+        }
+
+        return {
+            ...slide,
+            style: resolvedStyle,
+            slots: processedSlots,
+            warnings: warnings.length > 0 ? warnings : undefined,
+            metrics: {
+                heights
+            }
+        };
+    });
+
+    return {
+        manifesto,
+        slides: resolvedSlides,
+        basePath,
+        warnings: globalWarnings.length > 0 ? globalWarnings : undefined
+    };
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './models/ir.js';
+export * from './emitter.js';
+export * from './parser/tokenizer.js';
+export * from './parser/manifesto.js';
+export * from './layouts/validator.js';
+export * from './interface/export-plugin.js';
+export * from './processor.js'; // Will create this next

package/src/interface/export-plugin.ts

@@ -0,0 +1,5 @@
+import { StoneDeckIR } from '../models/ir.js';
+
+export interface ExportPlugin {
+    generate(ir: StoneDeckIR, outputPath: string, options?: any): Promise<void>;
+}

package/src/layouts/layout-generator.ts

@@ -0,0 +1,116 @@
+
+import { Layout, LayoutSlot } from '../models/ir.js';
+
+export class LayoutGenerator {
+    private static CANVAS_WIDTH = 720;
+    private static CANVAS_HEIGHT = 405;
+    private static SAFETY_MARGIN = 30;
+
+    /**
+     * Generates a dynamic layout based on valid base types.
+     */
+    static generate(layoutId: string, slotCount: number): Layout | null {
+        if (layoutId === 'content') {
+            return this.generateContentGrid(slotCount);
+        }
+        if (layoutId === 'title-and-content') {
+            return this.generateTitleAndContent(slotCount);
+        }
+        return null;
+    }
+
+    private static generateContentGrid(count: number): Layout {
+        // Full canvas usage
+        const bounds = {
+            x: this.SAFETY_MARGIN,
+            y: this.SAFETY_MARGIN,
+            w: this.CANVAS_WIDTH - (this.SAFETY_MARGIN * 2),
+            h: this.CANVAS_HEIGHT - (this.SAFETY_MARGIN * 2)
+        };
+
+        return {
+            id: 'content',
+            slots: this.calculateGridSlots(count, bounds)
+        };
+    }
+
+    private static generateTitleAndContent(count: number): Layout {
+        // Slot 0 is always Title (Top)
+        // Slots 1..N are Body Content (Bottom)
+
+        const titleHeight = 120;
+        const spacing = 20;
+
+        const titleSlot: LayoutSlot = {
+            id: 'title',
+            x: this.SAFETY_MARGIN,
+            y: 30,
+            width: this.CANVAS_WIDTH - (this.SAFETY_MARGIN * 2),
+            height: titleHeight
+        };
+
+        if (count <= 1) {
+            return {
+                id: 'title-and-content',
+                slots: [titleSlot]
+            };
+        }
+
+        const bodyBounds = {
+            x: this.SAFETY_MARGIN,
+            y: 30 + titleHeight + spacing,
+            w: this.CANVAS_WIDTH - (this.SAFETY_MARGIN * 2),
+            h: this.CANVAS_HEIGHT - (30 + titleHeight + spacing) - 30
+        };
+
+        const bodySlots = this.calculateGridSlots(count - 1, bodyBounds, 1); // offset index by 1
+
+        return {
+            id: 'title-and-content',
+            slots: [titleSlot, ...bodySlots]
+        };
+    }
+
+    private static calculateGridSlots(count: number, bounds: { x: number, y: number, w: number, h: number }, indexOffset: number = 0): LayoutSlot[] {
+        const slots: LayoutSlot[] = [];
+        if (count === 0) return slots;
+
+        // Simple Grid Logic
+        // 1: 1x1
+        // 2: 2 cols
+        // 3: 3 cols
+        // 4: 2x2
+        // 5: 3x2 (last row 2 center? No, simple grid for now)
+        // 6: 3x2
+        // 7-8: 4x2
+        // 9: 3x3
+
+        let cols = 1;
+        let rows = 1;
+
+        if (count === 2) { cols = 2; }
+        else if (count === 3) { cols = 3; }
+        else if (count === 4) { cols = 2; rows = 2; }
+        else if (count === 5 || count === 6) { cols = 3; rows = 2; }
+        else if (count > 6) { cols = Math.ceil(Math.sqrt(count)); rows = Math.ceil(count / cols); }
+
+        const cellW = (bounds.w - (cols - 1) * 20) / cols;
+        const cellH = (bounds.h - (rows - 1) * 20) / rows;
+        const gap = 20;
+
+        for (let i = 0; i < count; i++) {
+            const r = Math.floor(i / cols);
+            const c = i % cols;
+
+            slots.push({
+                id: `slot_${i + indexOffset}`,
+                x: bounds.x + c * (cellW + gap),
+                y: bounds.y + r * (cellH + gap),
+                width: cellW,
+                height: cellH
+            });
+        }
+
+        return slots;
+    }
+}

package/src/layouts/registry.json

@@ -0,0 +1,290 @@
+{
+    "layouts": [
+        {
+            "id": "section-header",
+            "slots": [
+                {
+                    "id": "title",
+                    "x": 50,
+                    "y": 180,
+                    "width": 620,
+                    "height": 60
+                }
+            ]
+        },
+        {
+            "id": "title",
+            "slots": [
+                {
+                    "id": "title",
+                    "x": 50,
+                    "y": 120,
+                    "width": 620,
+                    "height": 100
+                },
+                {
+                    "id": "subtitle",
+                    "x": 50,
+                    "y": 230,
+                    "width": 620,
+                    "height": 80
+                }
+            ]
+        },
+        {
+            "id": "title-and-content",
+            "slots": [
+                {
+                    "id": "title",
+                    "x": 50,
+                    "y": 30,
+                    "width": 620,
+                    "height": 60
+                },
+                {
+                    "id": "body",
+                    "x": 50,
+                    "y": 100,
+                    "width": 620,
+                    "height": 280
+                }
+            ]
+        },
+        {
+            "id": "title-and-content",
+            "slots": [
+                {
+                    "id": "title",
+                    "x": 50,
+                    "y": 30,
+                    "width": 620,
+                    "height": 60
+                },
+                {
+                    "id": "col1",
+                    "x": 50,
+                    "y": 100,
+                    "width": 300,
+                    "height": 280
+                },
+                {
+                    "id": "col2",
+                    "x": 370,
+                    "y": 100,
+                    "width": 300,
+                    "height": 280
+                }
+            ]
+        },
+        {
+            "id": "title-and-content",
+            "slots": [
+                {
+                    "id": "title",
+                    "x": 50,
+                    "y": 30,
+                    "width": 620,
+                    "height": 60
+                },
+                {
+                    "id": "col1",
+                    "x": 50,
+                    "y": 100,
+                    "width": 190,
+                    "height": 280
+                },
+                {
+                    "id": "col2",
+                    "x": 260,
+                    "y": 100,
+                    "width": 190,
+                    "height": 280
+                },
+                {
+                    "id": "col3",
+                    "x": 470,
+                    "y": 100,
+                    "width": 190,
+                    "height": 280
+                }
+            ]
+        },
+        {
+            "id": "title-and-content",
+            "slots": [
+                {
+                    "id": "title",
+                    "x": 50,
+                    "y": 30,
+                    "width": 620,
+                    "height": 60
+                },
+                {
+                    "id": "card1",
+                    "x": 50,
+                    "y": 100,
+                    "width": 300,
+                    "height": 135
+                },
+                {
+                    "id": "card2",
+                    "x": 370,
+                    "y": 100,
+                    "width": 300,
+                    "height": 135
+                },
+                {
+                    "id": "card3",
+                    "x": 50,
+                    "y": 245,
+                    "width": 300,
+                    "height": 135
+                },
+                {
+                    "id": "card4",
+                    "x": 370,
+                    "y": 245,
+                    "width": 300,
+                    "height": 135
+                }
+            ]
+        },
+        {
+            "id": "content",
+            "slots": [
+                {
+                    "id": "body",
+                    "x": 50,
+                    "y": 50,
+                    "width": 620,
+                    "height": 300
+                }
+            ]
+        },
+        {
+            "id": "content",
+            "slots": [
+                {
+                    "id": "col1",
+                    "x": 50,
+                    "y": 50,
+                    "width": 300,
+                    "height": 300
+                },
+                {
+                    "id": "col2",
+                    "x": 370,
+                    "y": 50,
+                    "width": 300,
+                    "height": 300
+                }
+            ]
+        },
+        {
+            "id": "content",
+            "slots": [
+                {
+                    "id": "col1",
+                    "x": 50,
+                    "y": 50,
+                    "width": 190,
+                    "height": 300
+                },
+                {
+                    "id": "col2",
+                    "x": 260,
+                    "y": 50,
+                    "width": 190,
+                    "height": 300
+                },
+                {
+                    "id": "col3",
+                    "x": 470,
+                    "y": 50,
+                    "width": 190,
+                    "height": 300
+                }
+            ]
+        },
+        {
+            "id": "content",
+            "slots": [
+                {
+                    "id": "card1",
+                    "x": 50,
+                    "y": 50,
+                    "width": 300,
+                    "height": 140
+                },
+                {
+                    "id": "card2",
+                    "x": 370,
+                    "y": 50,
+                    "width": 300,
+                    "height": 140
+                },
+                {
+                    "id": "card3",
+                    "x": 50,
+                    "y": 210,
+                    "width": 300,
+                    "height": 140
+                },
+                {
+                    "id": "card4",
+                    "x": 370,
+                    "y": 210,
+                    "width": 300,
+                    "height": 140
+                }
+            ]
+        },
+        {
+            "id": "content",
+            "slots": [
+                {
+                    "id": "card1",
+                    "x": 50,
+                    "y": 50,
+                    "width": 190,
+                    "height": 140
+                },
+                {
+                    "id": "card2",
+                    "x": 260,
+                    "y": 50,
+                    "width": 190,
+                    "height": 140
+                },
+                {
+                    "id": "card3",
+                    "x": 470,
+                    "y": 50,
+                    "width": 190,
+                    "height": 140
+                },
+                {
+                    "id": "card4",
+                    "x": 50,
+                    "y": 210,
+                    "width": 190,
+                    "height": 140
+                },
+                {
+                    "id": "card5",
+                    "x": 260,
+                    "y": 210,
+                    "width": 190,
+                    "height": 140
+                },
+                {
+                    "id": "card6",
+                    "x": 470,
+                    "y": 210,
+                    "width": 190,
+                    "height": 140
+                }
+            ]
+        }
+    ]
+}

package/src/layouts/validator.ts

@@ -0,0 +1,31 @@
+import { Layout } from '../models/ir.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { LayoutGenerator } from './layout-generator.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const registryPath = path.join(__dirname, 'registry.json');
+const registry = JSON.parse(fs.readFileSync(registryPath, 'utf-8'));
+
+export function validateLayout(id: string, slotCount: number): { valid: boolean; error?: string } {
+    const layout = getLayout(id, slotCount);
+    if (!layout) {
+        return { valid: false, error: `Layout '${id}' not found for ${slotCount} slots.` };
+    }
+    return { valid: true };
+}
+
+export function getLayout(id: string, slotCount: number): Layout | undefined {
+    // 1. Try Registry First (Static definitions override dynamic)
+    const layout = registry.layouts.find((l: any) => l.id === id && l.slots.length === slotCount);
+    if (layout) return layout;
+
+    // 2. Try Dynamic Generator
+    const dynamic = LayoutGenerator.generate(id, slotCount);
+    if (dynamic) return dynamic;
+
+    return undefined;
+}

package/src/models/ir.ts

@@ -0,0 +1,98 @@
+export interface StoneDeckManifesto {
+  StoneDeck: boolean;
+  title: string;
+  subtitle?: string;
+  theme: string;
+  author?: string;
+}
+
+export interface ListItem {
+  text: string;
+  level: number;
+  bullet_type: 'dot' | 'square' | 'arrow' | 'dash' | 'number' | string;
+}
+
+export interface TableCell {
+  text: string;
+  isHeader: boolean;
+  align?: 'left' | 'center' | 'right';
+}
+
+export interface SlideStyle {
+  background?: {
+    type: 'color' | 'image' | 'gradient';
+    value?: string;
+    src?: string;
+    opacity?: number;
+    fit?: 'cover' | 'contain';
+    colors?: string[];
+    direction?: string;
+  };
+  content_align?: {
+    horizontal?: 'left' | 'center' | 'right';
+    vertical?: 'top' | 'middle' | 'bottom';
+  };
+  card?: {
+    background?: string;
+    radius?: string;
+    border?: string;
+    shadow?: boolean;
+    content_align?: {
+      horizontal?: 'left' | 'center' | 'right';
+      vertical?: 'top' | 'middle' | 'bottom';
+    };
+  };
+  list?: {
+    bullet_type?: string;
+    bullet_color?: string;
+    spacing?: string;
+    indent?: string;
+  };
+  [key: string]: any;
+}
+
+export type SlotContent = {
+  type: 'markdown';
+  raw: string;
+} | {
+  type: 'list';
+  items: ListItem[];
+} | {
+  type: 'table';
+  rows: TableCell[][];
+} | {
+  type: 'image';
+  src: string;
+  alt?: string;
+};
+
+export interface Slide {
+  layout_id: string;
+  title?: string; // Optional slide title
+  style: SlideStyle;
+  slots: SlotContent[]; // Content of each slot (Structured)
+  warnings?: string[] | undefined;
+  metrics?: {
+    heights: number[]; // Height of each slot in pt
+  } | undefined;
+}
+
+export interface StoneDeckIR {
+  manifesto: StoneDeckManifesto;
+  slides: Slide[];
+  basePath: string; // Base directory for resource resolution (images, themes)
+  warnings?: string[] | undefined;
+}
+
+export interface LayoutSlot {
+  id: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface Layout {
+  id: string;
+  slots: LayoutSlot[];
+}

package/src/parser/image-mapper.ts

@@ -0,0 +1,14 @@
+/**
+ * Detects a Markdown image in a string.
+ */
+export function mapMarkdownImage(markdown: string): { src: string; alt?: string } | null {
+    // Regex for ![alt](src)
+    const match = markdown.trim().match(/^!\[(.*?)\]\((.*?)\)$/);
+    if (match && match[1] !== undefined && match[2] !== undefined) {
+        return {
+            alt: match[1],
+            src: match[2]
+        };
+    }
+    return null;
+}