@stonedeck/core 0.7.0

package/src/parser/list-mapper.ts

@@ -0,0 +1,28 @@
+import { ListItem } from '../models/ir.js';
+
+export function mapMarkdownLists(markdown: string): ListItem[] {
+    const lines = markdown.split(/\r?\n/);
+    const items: ListItem[] = [];
+
+    for (const line of lines) {
+        // Regex matches: leading spaces, asterisk/dash/number, then the text
+        const match = line.match(/^(\s*)([-*+]|\d+\.)\s+(.*)$/);
+        if (match) {
+            const indentation = match[1]!.length;
+            const bullet = match[2]!;
+            const text = match[3]!;
+
+            // RFC 9.2: Hierarquia até 3 níveis. 
+            // Assuming 2 spaces per level.
+            const level = Math.min(Math.floor(indentation / 2) + 1, 3);
+
+            let bullet_type = 'dot';
+            if (bullet === '-') bullet_type = 'dash';
+            if (/^\d+\./.test(bullet)) bullet_type = 'number';
+
+            items.push({ text, level, bullet_type });
+        }
+    }
+
+    return items;
+}

package/src/parser/manifesto.ts

@@ -0,0 +1,49 @@
+import * as YAML from 'yaml';
+import { StoneDeckManifesto } from '../models/ir.js';
+
+export class ManifestoValidationError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'ManifestoValidationError';
+    }
+}
+
+export function parseManifesto(content: string): { manifesto: StoneDeckManifesto; remainingContent: string } {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+
+    if (!match) {
+        throw new ManifestoValidationError('Manifesto block (--- ... ---) not found at the beginning of the file.');
+    }
+
+    const yamlContent = match[1]!;
+    const remainingContent = content.slice(match[0].length).trim();
+
+    let data: any;
+    try {
+        data = YAML.parse(yamlContent);
+    } catch (e: any) {
+        throw new ManifestoValidationError(`Failed to parse Manifesto YAML: ${e.message}`);
+    }
+
+    if (data?.StoneDeck !== true) {
+        throw new ManifestoValidationError('Manifesto must contain "StoneDeck: true" to be processed.');
+    }
+
+    if (!data.title) {
+        throw new ManifestoValidationError('Manifesto must contain a "title".');
+    }
+
+    if (!data.theme) {
+        throw new ManifestoValidationError('Manifesto must contain a "theme".');
+    }
+
+    const manifesto: StoneDeckManifesto = {
+        StoneDeck: true,
+        title: data.title,
+        subtitle: data.subtitle,
+        theme: data.theme,
+        author: data.author,
+    };
+
+    return { manifesto, remainingContent };
+}

package/src/parser/table-mapper.ts

@@ -0,0 +1,38 @@
+import { TableCell } from '../models/ir.js';
+
+/**
+ * Simple Markdown table parser.
+ * It identifies tables and converts them into a 2D array of TableCells.
+ */
+export function mapMarkdownTable(markdown: string): TableCell[][] | null {
+    const lines = markdown.split(/\r?\n/).map(l => l.trim()).filter(l => l.length > 0);
+
+    // Minimum table has 2 lines: header and delimiter
+    if (lines.length < 2) return null;
+
+    // Check if the first line is a table header
+    const firstLine = lines[0];
+    if (!firstLine || !firstLine.startsWith('|') || !firstLine.endsWith('|')) return null;
+
+    // Check for delimiter line (|---|---|)
+    const delimiterLine = lines[1];
+    if (!delimiterLine || !delimiterLine.includes('|') || !delimiterLine.includes('-')) return null;
+
+    const rows: TableCell[][] = [];
+
+    // Helper to split row correctly
+    const splitRow = (row: string) => row.replace(/^\||\|$/g, '').split('|').map(c => c.trim());
+
+    const headers = splitRow(firstLine);
+    rows.push(headers.map(h => ({ text: h, isHeader: true })));
+
+    // Parse Body
+    for (let i = 2; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line || !line.startsWith('|')) break;
+        const cells = splitRow(line);
+        rows.push(cells.map(c => ({ text: c, isHeader: false })));
+    }
+
+    return rows.length > 1 ? rows : null;
+}

package/src/parser/tokenizer.ts

@@ -0,0 +1,126 @@
+import * as YAML from 'yaml';
+import { Slide, SlotContent } from '../models/ir.js';
+import { mapMarkdownImage } from './image-mapper.js';
+
+export function tokenizeSlides(remainingContent: string): Slide[] {
+    // Slides are separated by ---
+    // Note: Since the content starts after the manifesto ---, the first slide delimiter might already be consumed or not exist.
+    // The RFC says: "O motor divide o restante do documento por ---."
+
+    const slideBlocks = remainingContent.split(/\r?\n---\r?\n/);
+    const slides: Slide[] = [];
+
+    for (const block of slideBlocks) {
+        if (!block.trim()) continue;
+
+        // Each slide block: Toggle between A (Yaml) and B (Markdown)
+        // Actually the RFC says:
+        // Estado A (Config): YAML define layout e style
+        // Estado B (Conteúdo): Markdown injetado nos slots
+
+        // Pattern: 
+        // layout: ...
+        // style: ...
+        // ---
+        // # Title
+        // ***
+        // Body
+
+        // In our case, the slide block itself contains BOTH parts separated by --- internally?
+        // RFC 8.3: "O motor divide o restante do documento por ---."
+        // "Estado A (Config): YAML"
+        // "Estado B (Conteúdo): Markdown"
+
+        // Wait, the RFC says "O motor divide o restante do documento por ---"
+        // And then says "Alternância de Contexto (Toggle): A (Config) -> B (Conteúdo)"
+        // This means Slide 1 Config --- Slide 1 Content --- Slide 2 Config --- Slide 2 Content
+
+        // Let's re-read carefully:
+        // 2. Iteração de Slides: O motor divide o restante do documento por ---.
+        // 3. Alternância de Contexto (Toggle): A (Config) -> B (Conteùdo)
+
+        // This implies that slide 1 is block 1 (config) and block 2 (content).
+        // Slide 2 is block 3 (config) and block 4 (content).
+    }
+
+    return slides;
+}
+
+export function parseSlides(content: string): Slide[] {
+    // Strict V2 syntax: Content must be inside :::slide blocks
+    return parseSlidesV2(content);
+}
+
+function parseSlidesV2(content: string): Slide[] {
+    const slides: Slide[] = [];
+    const slideRegex = /:::slide([\s\S]*?):::/g;
+    let match;
+
+    while ((match = slideRegex.exec(content)) !== null) {
+        const slideBlock = match[1]?.trim() || '';
+
+        // Extract Front Matter
+        // Pattern: ^--- (yaml) --- (content)$
+        const fmRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+        const fmMatch = slideBlock.match(fmRegex);
+
+        let config: any = {};
+        let rawContent = slideBlock;
+
+        if (fmMatch) {
+            const yamlStr = fmMatch[1] || '';
+            rawContent = fmMatch[2] || '';
+            try {
+                config = YAML.parse(yamlStr);
+            } catch (e) {
+                console.warn('Invalid YAML in slide:', e);
+            }
+        }
+
+        const layout_id = config.layout || 'blank';
+        const title = config.title;
+        const style = config.style || {};
+
+        const slots = parseSlots(rawContent);
+
+        slides.push({
+            layout_id,
+            title,
+            style,
+            slots
+        });
+    }
+
+    return slides;
+}
+
+function parseSlots(content: string): SlotContent[] {
+    let processedContent = content.trim();
+
+    // Handle comments inside content (Cycle 2 requirement)
+    // Removed here or handled by plugins? Actually comments should be removed BEFORE splitting slots?
+    // Let's assume content is pure markdown for now.
+
+    // Remove *-* at start/end
+    processedContent = processedContent.replace(/^\*-\*\s*[\r\n]+/, '');
+    processedContent = processedContent.replace(/[\r\n]+\s*\*-\*\s*$/, '');
+
+    const slots_content = processedContent
+        ? processedContent.split(/\r?\n\*-\*\r?\n/).map(s => s.trim()).filter(s => s.length > 0)
+        : [];
+
+    // If no delimiters found but content exists, treat as single slot
+    if (slots_content.length === 0 && processedContent.length > 0) {
+        const img = mapMarkdownImage(processedContent);
+        if (img) return [{ type: 'image', src: img.src, alt: img.alt }];
+        return [{ type: 'markdown', raw: processedContent }];
+    }
+
+    return slots_content.map(raw => {
+        const img = mapMarkdownImage(raw);
+        if (img) {
+            return { type: 'image', src: img.src, alt: img.alt };
+        }
+        return { type: 'markdown', raw };
+    });
+}

package/src/processor.ts

@@ -0,0 +1,6 @@
+import { emitIR } from './emitter.js';
+import { StoneDeckIR } from './models/ir.js';
+
+export function processStoneDeck(content: string, filePath: string, themeOverride?: string): StoneDeckIR {
+    return emitIR(content, filePath, themeOverride);
+}

package/src/resolver/metrics.ts

@@ -0,0 +1,64 @@
+import PDFDocument from 'pdfkit';
+import { SlideStyle } from '../models/ir.js';
+
+export interface LayoutSlot {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+export interface LayoutDefinition {
+    id: string;
+    slots: LayoutSlot[];
+}
+
+export class MetricsCalculator {
+    private doc: PDFKit.PDFDocument;
+
+    constructor() {
+        // Create a headless PDF document for measurements
+        this.doc = new PDFDocument({ size: [720, 405] });
+    }
+
+    /**
+     * Calculates the height of a string given a font and width.
+     */
+    calculateTextHeight(text: string, style: SlideStyle, maxWidth: number): number {
+        const fontSize = style.font_size || 18; // Default font size
+        const font = style.font_family || 'Helvetica'; // Default font
+
+        try {
+            this.doc.font(font).fontSize(fontSize);
+            return this.doc.heightOfString(text, { width: maxWidth });
+        } catch (e) {
+            // Fallback font if the requested one fails
+            this.doc.font('Helvetica').fontSize(fontSize);
+            return this.doc.heightOfString(text, { width: maxWidth });
+        }
+    }
+
+    /**
+     * Estimates height for Markdown content.
+     * For now, this is a simplified version that handles basic text and lists.
+     */
+    estimateMarkdownHeight(markdown: string, style: SlideStyle, maxWidth: number): number {
+        // Simple heuristic: split by lines and sum heights
+        // In a real implementation, this would handle actual markdown parsing.
+        const lines = markdown.split('\n');
+        let totalHeight = 0;
+
+        for (const line of lines) {
+            if (!line.trim()) {
+                totalHeight += (style.font_size || 18) * 0.5; // Half line height for empty lines
+                continue;
+            }
+            totalHeight += this.calculateTextHeight(line, style, maxWidth);
+        }
+
+        return totalHeight;
+    }
+}
+
+export const metricsCalculator = new MetricsCalculator();

package/src/resolver/theme-loader.ts

@@ -0,0 +1,122 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as YAML from 'yaml';
+import { fileURLToPath } from 'url';
+import { SlideStyle } from '../models/ir.js';
+
+export class ThemeLoader {
+    private static __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+    private static presets: Record<string, any> = {
+        dark: {
+            name: "Dark Preset",
+            tokens: {
+                colors: { primary: "#1A1A2E", secondary: "#16213E", accent: "#E94560", surface: "#0F3460", text: "#FFFFFF" },
+                fonts: { heading: "Montserrat", body: "Open Sans", mono: "Fira Code" }
+            }
+        },
+        standard: {
+            name: "Standard Preset",
+            tokens: {
+                colors: { primary: "#FFFFFF", secondary: "#F0F0F0", accent: "#007BFF", surface: "#FFFFFF", text: "#000000" },
+                fonts: { heading: "Inter", body: "Roboto", mono: "Courier New" }
+            }
+        }
+    };
+
+    static load(themeRef: string, basePath: string): any {
+        if (this.presets[themeRef]) {
+            return this.presets[themeRef];
+        }
+
+        const potentialPaths = [
+            path.isAbsolute(themeRef) ? themeRef : path.join(basePath, themeRef),
+            path.isAbsolute(themeRef) ? themeRef : path.join(basePath, 'themes', themeRef + '.yaml'),
+            path.join(this.__dirname, '../../themes', themeRef + '.yaml'), // When running from built/source
+            path.join(this.__dirname, '../../src/themes', themeRef + '.yaml'), // Fallback to src if not copied to dist
+            path.join(process.cwd(), 'src/themes', themeRef + '.yaml') // Development fall back
+        ];
+
+        for (const p of potentialPaths) {
+            if (fs.existsSync(p)) {
+                try {
+                    const fileContent = fs.readFileSync(p, 'utf8');
+                    return YAML.parse(fileContent);
+                } catch (e) {
+                    console.warn(`Failed to parse theme at ${p}:`, e);
+                }
+            }
+        }
+
+        console.warn(`Theme "${themeRef}" not found. Falling back to standard.`);
+        return this.presets.standard;
+    }
+
+    static resolveStyle(slideStyle: SlideStyle, theme: any): SlideStyle {
+        const tokens = theme.tokens || {};
+        return this.deepResolve(slideStyle, tokens);
+    }
+
+    private static deepResolve(obj: any, tokens: any): any {
+        if (typeof obj !== 'object' || obj === null) {
+            // Token resolution for strings
+            if (typeof obj === 'string') {
+                return this.resolveTokenValue(obj, tokens);
+            }
+            return obj;
+        }
+
+        if (Array.isArray(obj)) {
+            return obj.map(item => this.deepResolve(item, tokens));
+        }
+
+        const resolved: any = {};
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                resolved[key] = this.deepResolve(obj[key], tokens);
+            }
+        }
+        return resolved;
+    }
+
+    private static resolveTokenValue(value: string, tokens: any): any {
+        // 1. Try resolving as a color token (e.g., "primary")
+        if (tokens.colors?.[value]) return tokens.colors[value];
+
+        // 2. Try resolving as a font token (e.g., "heading")
+        if (tokens.fonts?.[value]) return tokens.fonts[value];
+
+        // 3. Try resolving as a spacing token
+        if (tokens.spacing?.[value]) return this.convertToPt(tokens.spacing[value]);
+
+        // 4. Try converting the string itself if it's a unit (e.g., "20px")
+        return this.convertToPt(value);
+    }
+
+    /**
+     * Converts various units into Points (pt).
+     * 1px ≈ 0.75pt
+     * 1em ≈ 12pt (assuming 16px base)
+     * RFC 4.1: "Todas as unidades finais devem ser em pt (Pontos)."
+     */
+    private static convertToPt(value: string | number): any {
+        if (typeof value === 'number') return value;
+
+        const match = value.match(/^([\d.]+)(px|em|rem|pt|%)?$/);
+        if (!match) return value;
+
+        const numStr = match[1];
+        if (!numStr) return value;
+
+        const num = parseFloat(numStr);
+        const unit = match[2];
+
+        switch (unit) {
+            case 'px': return num * 0.75;
+            case 'em':
+            case 'rem': return num * 12; // Simple approximation for 1em = 16px
+            case 'pt': return num;
+            default: return num;
+        }
+    }
+}

package/src/themes/academico.yaml

@@ -0,0 +1,25 @@
+name: "Academico"
+tokens:
+  colors:
+    primary: "#1a237e"
+    secondary: "#f3e5f5"
+    accent: "#b71c1c"
+    surface: "#fdfbf7"
+    text: "#212121"
+    heading: "#1a237e"
+    table_header: "#e8eaf6"
+  fonts:
+    heading: "Times-Bold"
+    body: "Times-Roman"
+    mono: "Courier"
+
+defaults:
+  background:
+    type: "color"
+    value: "surface"
+  color: "text"
+  font_family: "body"
+  font_size: 20
+  content_align:
+    horizontal: "left"
+    vertical: "top"

package/src/themes/corporativo.yaml

@@ -0,0 +1,25 @@
+name: "Corporativo"
+tokens:
+  colors:
+    primary: "#2980b9"
+    secondary: "#dfe6e9"
+    accent: "#3498db"
+    surface: "#f0f2f5"
+    text: "#2c3e50"
+    heading: "#2980b9"
+    border: "#34495e"
+  fonts:
+    heading: "Helvetica-Bold"
+    body: "Helvetica"
+    mono: "Courier New"
+
+defaults:
+  background:
+    type: "color"
+    value: "surface"
+  color: "text"
+  font_family: "body"
+  font_size: 20
+  content_align:
+    horizontal: "left"
+    vertical: "top"

package/src/themes/dark_mode.yaml

@@ -0,0 +1,26 @@
+name: "Dark Mode"
+tokens:
+  colors:
+    primary: "#64ffda"
+    secondary: "#112240"
+    accent: "#64ffda"
+    surface: "#0a192f"
+    text: "#e6f1ff"
+    heading: "#64ffda"
+    muted: "#8892b0"
+    code: "#ff9f43"
+  fonts:
+    heading: "Helvetica-Bold"
+    body: "Helvetica"
+    mono: "Courier New"
+
+defaults:
+  background:
+    type: "color"
+    value: "surface"
+  color: "text"
+  font_family: "body"
+  font_size: 20
+  content_align:
+    horizontal: "left"
+    vertical: "top"

package/src/themes/minimalista.yaml

@@ -0,0 +1,25 @@
+name: "Minimalista"
+tokens:
+  colors:
+    primary: "#000000"
+    secondary: "#ffffff"
+    accent: "#000000"
+    surface: "#ffffff"
+    text: "#333333"
+    heading: "#000000"
+    muted: "#555555"
+  fonts:
+    heading: "Helvetica-Bold"
+    body: "Helvetica"
+    mono: "Courier New"
+
+defaults:
+  background:
+    type: "color"
+    value: "surface"
+  color: "text"
+  font_family: "body"
+  font_size: 24
+  content_align:
+    horizontal: "left"
+    vertical: "top"

package/src/themes/moderno.yaml

@@ -0,0 +1,26 @@
+name: "Moderno"
+tokens:
+  colors:
+    primary: "#2c3e50"
+    secondary: "#ecf0f1"
+    accent: "#3498db"
+    surface: "#f5f7fa"
+    text: "#34495e"
+    heading: "#2c3e50"
+    muted: "#7f8c8d"
+    quote_bg: "#e1f5fe"
+  fonts:
+    heading: "Helvetica-Bold"
+    body: "Helvetica"
+    mono: "Courier New"
+
+defaults:
+  background:
+    type: "color"
+    value: "surface"
+  color: "text"
+  font_family: "body"
+  font_size: 20
+  content_align:
+    horizontal: "left"
+    vertical: "top"

package/test/cycle2_markdown.test.ts

@@ -0,0 +1,36 @@
+import { mapMarkdownLists } from '../src/parser/list-mapper';
+
+describe('Cycle 2 Markdown Support', () => {
+    it('should support + bullet points', () => {
+        const markdown = '+ Item 1\n+ Item 2';
+        const result = mapMarkdownLists(markdown);
+        expect(result).toHaveLength(2);
+        expect(result[0]?.text).toBe('Item 1');
+        // bullet_type default is dot if not dash/number
+        expect(result[0]?.bullet_type).toBe('dot');
+    });
+
+    it('should support * bullet points', () => {
+        const markdown = '* Item 1\n* Item 2';
+        const result = mapMarkdownLists(markdown);
+        expect(result).toHaveLength(2);
+        expect(result[0]?.bullet_type).toBe('dot');
+    });
+
+    it('should support mixed lists', () => {
+        const markdown = '- Dash\n+ Plus\n* Star';
+        const result = mapMarkdownLists(markdown);
+        expect(result).toHaveLength(3);
+        expect(result[0]?.bullet_type).toBe('dash');
+        expect(result[1]?.bullet_type).toBe('dot');
+        expect(result[2]?.bullet_type).toBe('dot');
+    });
+
+    it('should support numbered lists', () => {
+        const markdown = '1. First\n2. Second';
+        const result = mapMarkdownLists(markdown);
+        expect(result).toHaveLength(2);
+        expect(result[0]?.bullet_type).toBe('number');
+        expect(result[1]?.bullet_type).toBe('number');
+    });
+});

package/test/cycle2_slides.test.ts

@@ -0,0 +1,52 @@
+import { parseSlides } from '../src/parser/tokenizer';
+
+describe('Cycle 2 Slide Contract (V2)', () => {
+    it('should parse :::slide block format', () => {
+        const content = `
+:::slide
+---
+layout: title-slide
+title: Hello V2
+---
+# Content Here
+:::
+        `;
+        const slides = parseSlides(content);
+        expect(slides).toHaveLength(1);
+        expect(slides[0]?.layout_id).toBe('title-slide');
+        expect(slides[0]?.title).toBe('Hello V2');
+        expect((slides[0]?.slots[0] as any)?.raw.trim()).toBe('# Content Here');
+    });
+
+    it('should detect front matter inside :::slide', () => {
+        const content = `
+:::slide
+---
+layout: two-columns
+style:
+  color: red
+---
+Left
+*-*
+Right
+:::
+        `;
+        const slides = parseSlides(content);
+        expect(slides).toHaveLength(1);
+        expect(slides[0]?.layout_id).toBe('two-columns');
+        expect(slides[0]?.style.color).toBe('red');
+        expect(slides[0]?.slots).toHaveLength(2);
+        expect((slides[0]?.slots[0] as any)?.raw.trim()).toBe('Left');
+        expect((slides[0]?.slots[1] as any)?.raw.trim()).toBe('Right');
+    });
+
+    it('should ignore content outside :::slide blocks (V1 format)', () => {
+        const content = `
+layout: simple
+---
+# Old Format
+        `;
+        const slides = parseSlides(content);
+        expect(slides).toHaveLength(0);
+    });
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "outDir": "dist",
+        "rootDir": "src",
+        "composite": true,
+        "resolveJsonModule": true
+    },
+    "include": [
+        "src/**/*",
+        "src/**/*.json"
+    ],
+    "exclude": [
+        "**/*.test.ts",
+        "**/*.test.tsx"
+    ]
+}