react-embed-docs 0.1.0

package/dist/server/ExportService.js

@@ -0,0 +1,501 @@
+/**
+ * Service for exporting documents to various formats
+ */
+export class ExportService {
+    /**
+     * Export document to DOCX format
+     * Requires 'docx' package to be installed
+     */
+    async exportToDocx(document, options = {}) {
+        const { includeTitle = true, includeEmoji = true } = options;
+        try {
+            // Dynamic import to avoid bundling docx when not used
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const docx = await import('docx');
+            const { Document, Paragraph, TextRun, HeadingLevel, Packer } = docx;
+            const children = [];
+            // Add title
+            if (includeTitle) {
+                const titleText = includeEmoji && document.emoji
+                    ? `${document.emoji} ${document.title}`
+                    : document.title;
+                children.push(new Paragraph({
+                    text: titleText,
+                    heading: HeadingLevel.HEADING_1,
+                    spacing: { after: 200 },
+                }));
+            }
+            // Convert content blocks to DOCX paragraphs
+            for (const block of document.content || []) {
+                const paragraph = this.blockToDocxParagraph(block, docx);
+                if (paragraph) {
+                    children.push(paragraph);
+                }
+            }
+            // Create document
+            const doc = new Document({
+                sections: [{
+                        properties: {},
+                        children,
+                    }],
+                creator: options.author || 'React Embed Docs',
+                company: options.company,
+                title: document.title,
+            });
+            // Generate buffer
+            const buffer = await Packer.toBuffer(doc);
+            return {
+                buffer,
+                filename: `${this.sanitizeFilename(document.title)}.docx`,
+                mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            };
+        }
+        catch (error) {
+            const errorMessage = error.message || String(error);
+            if (errorMessage.includes("Cannot find module 'docx'") || errorMessage.includes("Cannot find package 'docx'")) {
+                throw new Error("DOCX export requires the 'docx' package. Install it with: npm install docx");
+            }
+            throw error;
+        }
+    }
+    /**
+     * Export document to PDF format
+     * Requires 'puppeteer' or 'playwright' package to be installed
+     */
+    async exportToPdf(document, options = {}) {
+        const { includeTitle = true, includeEmoji = true, format = 'A4' } = options;
+        // Generate HTML content
+        const html = this.generateHtml(document, { includeTitle, includeEmoji });
+        // Try puppeteer first, then playwright
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let browser = null;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let page = null;
+        try {
+            // Try puppeteer
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const puppeteer = await import('puppeteer');
+                browser = await puppeteer.launch({ headless: true });
+            }
+            catch {
+                // Try playwright
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const { chromium } = await import('playwright');
+                    browser = await chromium.launch({ headless: true });
+                }
+                catch {
+                    throw new Error("PDF export requires either 'puppeteer' or 'playwright' package. " +
+                        "Install one with: npm install puppeteer" +
+                        " or: npm install playwright");
+                }
+            }
+            page = await browser.newPage();
+            await page.setContent(html, { waitUntil: 'networkidle0' });
+            // Generate PDF
+            const pdfBuffer = await page.pdf({
+                format,
+                printBackground: true,
+                margin: {
+                    top: options.margin?.top || '1in',
+                    right: options.margin?.right || '1in',
+                    bottom: options.margin?.bottom || '1in',
+                    left: options.margin?.left || '1in',
+                },
+            });
+            return {
+                buffer: Buffer.from(pdfBuffer),
+                filename: `${this.sanitizeFilename(document.title)}.pdf`,
+                mimeType: 'application/pdf',
+            };
+        }
+        finally {
+            if (browser) {
+                await browser.close();
+            }
+        }
+    }
+    /**
+     * Export document to HTML format
+     */
+    async exportToHtml(document, options = {}) {
+        const { includeTitle = true, includeEmoji = true } = options;
+        const html = this.generateHtml(document, { includeTitle, includeEmoji });
+        return {
+            buffer: Buffer.from(html, 'utf-8'),
+            filename: `${this.sanitizeFilename(document.title)}.html`,
+            mimeType: 'text/html',
+        };
+    }
+    /**
+     * Export document to Markdown format
+     */
+    async exportToMarkdown(document, options = {}) {
+        const { includeTitle = true, includeEmoji = true } = options;
+        let markdown = '';
+        // Add title
+        if (includeTitle) {
+            const title = includeEmoji && document.emoji
+                ? `${document.emoji} ${document.title}`
+                : document.title;
+            markdown += `# ${title}\n\n`;
+        }
+        // Convert blocks to markdown
+        for (const block of document.content || []) {
+            const blockMd = this.blockToMarkdown(block);
+            if (blockMd) {
+                markdown += blockMd + '\n\n';
+            }
+        }
+        return {
+            buffer: Buffer.from(markdown, 'utf-8'),
+            filename: `${this.sanitizeFilename(document.title)}.md`,
+            mimeType: 'text/markdown',
+        };
+    }
+    /**
+     * Convert a BlockNote block to DOCX Paragraph
+     */
+    blockToDocxParagraph(block, docx) {
+        const { Paragraph, TextRun, HeadingLevel, AlignmentType } = docx;
+        switch (block.type) {
+            case 'paragraph':
+                return new Paragraph({
+                    children: this.convertContentToTextRuns(block.content, TextRun),
+                    spacing: { after: 200 },
+                });
+            case 'heading': {
+                const level = block.props?.level || 1;
+                const headingLevel = level === 1 ? HeadingLevel.HEADING_1
+                    : level === 2 ? HeadingLevel.HEADING_2
+                        : level === 3 ? HeadingLevel.HEADING_3
+                            : HeadingLevel.HEADING_4;
+                return new Paragraph({
+                    children: this.convertContentToTextRuns(block.content, TextRun),
+                    heading: headingLevel,
+                    spacing: { before: 200, after: 100 },
+                });
+            }
+            case 'bulletListItem':
+                return new Paragraph({
+                    children: this.convertContentToTextRuns(block.content, TextRun),
+                    bullet: { level: 0 },
+                    spacing: { after: 100 },
+                });
+            case 'numberedListItem':
+                return new Paragraph({
+                    children: this.convertContentToTextRuns(block.content, TextRun),
+                    numbering: { reference: 'my-numbering', level: 0 },
+                    spacing: { after: 100 },
+                });
+            case 'checkListItem': {
+                const checked = block.props?.checked ? '☑ ' : '☐ ';
+                return new Paragraph({
+                    children: [
+                        new TextRun({ text: checked, bold: true }),
+                        ...this.convertContentToTextRuns(block.content, TextRun),
+                    ],
+                    spacing: { after: 100 },
+                });
+            }
+            case 'quote':
+                return new Paragraph({
+                    children: this.convertContentToTextRuns(block.content, TextRun),
+                    spacing: { after: 200 },
+                    border: {
+                        left: {
+                            color: '999999',
+                            space: 20,
+                            style: 'single',
+                            size: 24,
+                        },
+                    },
+                });
+            case 'codeBlock': {
+                const code = this.extractTextFromContent(block.content);
+                return new Paragraph({
+                    children: [new TextRun({ text: code, font: 'Courier New' })],
+                    spacing: { after: 200 },
+                    shading: { fill: 'F5F5F5' },
+                });
+            }
+            default: {
+                // Fallback for unknown blocks
+                const text = this.extractTextFromContent(block.content);
+                if (text) {
+                    return new Paragraph({
+                        text,
+                        spacing: { after: 200 },
+                    });
+                }
+                return null;
+            }
+        }
+    }
+    /**
+     * Convert BlockNote content items to TextRun array
+     */
+    convertContentToTextRuns(content, TextRun) {
+        if (!content)
+            return [];
+        const runs = [];
+        // Flatten nested arrays (BlockNote can have nested content)
+        const flatContent = Array.isArray(content[0])
+            ? content.flat()
+            : content;
+        for (const item of flatContent) {
+            if (!item)
+                continue;
+            const styles = {};
+            if (item.type === 'text') {
+                if (item.bold)
+                    styles.bold = true;
+                if (item.italic)
+                    styles.italics = true;
+                if (item.underline)
+                    styles.underline = { type: 'single' };
+                if (item.strike)
+                    styles.strike = true;
+                if (item.code) {
+                    styles.font = 'Courier New';
+                    styles.shading = { fill: 'F5F5F5' };
+                }
+                if (item.backgroundColor) {
+                    styles.shading = { fill: item.backgroundColor.replace('#', '') };
+                }
+                if (item.textColor) {
+                    styles.color = item.textColor.replace('#', '');
+                }
+                runs.push(new TextRun({ text: item.text || '', ...styles }));
+            }
+        }
+        return runs.length > 0 ? runs : [new TextRun({ text: '' })];
+    }
+    /**
+     * Extract plain text from content
+     */
+    extractTextFromContent(content) {
+        if (!content)
+            return '';
+        const flatContent = Array.isArray(content[0])
+            ? content.flat()
+            : content;
+        return flatContent
+            .map(item => item?.text || '')
+            .join('');
+    }
+    /**
+     * Generate HTML from document
+     */
+    generateHtml(document, options) {
+        const { includeTitle = true, includeEmoji = true } = options;
+        let body = '';
+        // Add title
+        if (includeTitle) {
+            const title = includeEmoji && document.emoji
+                ? `${document.emoji} ${document.title}`
+                : document.title;
+            body += `<h1>${this.escapeHtml(title)}</h1>`;
+        }
+        // Convert blocks to HTML
+        for (const block of document.content || []) {
+            body += this.blockToHtml(block);
+        }
+        return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <title>${this.escapeHtml(document.title)}</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      font-size: 16px;
+      line-height: 1.6;
+      color: #333;
+      max-width: 800px;
+      margin: 0 auto;
+      padding: 40px;
+    }
+    h1 { font-size: 2em; margin-bottom: 0.5em; }
+    h2 { font-size: 1.5em; margin-top: 1.5em; margin-bottom: 0.5em; }
+    h3 { font-size: 1.25em; margin-top: 1.25em; margin-bottom: 0.5em; }
+    p { margin-bottom: 1em; }
+    ul, ol { margin-bottom: 1em; padding-left: 2em; }
+    blockquote {
+      border-left: 4px solid #ddd;
+      margin: 0 0 1em 0;
+      padding-left: 1em;
+      color: #666;
+    }
+    pre {
+      background: #f5f5f5;
+      padding: 1em;
+      border-radius: 4px;
+      overflow-x: auto;
+    }
+    code {
+      font-family: 'Consolas', 'Monaco', monospace;
+      font-size: 0.9em;
+    }
+    img { max-width: 100%; height: auto; }
+    table { border-collapse: collapse; width: 100%; margin-bottom: 1em; }
+    th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+    th { background: #f5f5f5; }
+  </style>
+</head>
+<body>
+${body}
+</body>
+</html>`;
+    }
+    /**
+     * Convert a BlockNote block to HTML
+     */
+    blockToHtml(block) {
+        const content = this.renderContentToHtml(block.content);
+        switch (block.type) {
+            case 'paragraph':
+                return `<p>${content}</p>`;
+            case 'heading': {
+                const level = block.props?.level || 1;
+                return `<h${level}>${content}</h${level}>`;
+            }
+            case 'bulletListItem':
+                return `<ul><li>${content}</li></ul>`;
+            case 'numberedListItem':
+                return `<ol><li>${content}</li></ol>`;
+            case 'checkListItem': {
+                const checked = block.props?.checked;
+                const checkbox = checked ? '☑' : '☐';
+                return `<p>${checkbox} ${content}</p>`;
+            }
+            case 'quote':
+                return `<blockquote>${content}</blockquote>`;
+            case 'codeBlock':
+                return `<pre><code>${this.escapeHtml(this.extractTextFromContent(block.content))}</code></pre>`;
+            case 'image': {
+                const url = block.props?.url || '';
+                const caption = block.props?.caption || '';
+                return `<figure><img src="${this.escapeHtml(url)}" alt="${this.escapeHtml(caption)}"><figcaption>${this.escapeHtml(caption)}</figcaption></figure>`;
+            }
+            case 'table':
+                return this.renderTableToHtml(block);
+            case 'divider':
+                return '<hr>';
+            default:
+                return `<p>${content}</p>`;
+        }
+    }
+    /**
+     * Render content items to HTML
+     */
+    renderContentToHtml(content) {
+        if (!content)
+            return '';
+        const flatContent = Array.isArray(content[0])
+            ? content.flat()
+            : content;
+        return flatContent.map(item => this.contentItemToHtml(item)).join('');
+    }
+    /**
+     * Convert a single content item to HTML
+     */
+    contentItemToHtml(item) {
+        if (!item || !item.text)
+            return '';
+        let text = this.escapeHtml(item.text);
+        const styles = item;
+        if (styles.bold)
+            text = `<strong>${text}</strong>`;
+        if (styles.italic)
+            text = `<em>${text}</em>`;
+        if (styles.underline)
+            text = `<u>${text}</u>`;
+        if (styles.strike)
+            text = `<s>${text}</s>`;
+        if (styles.code)
+            text = `<code>${text}</code>`;
+        if (styles.backgroundColor)
+            text = `<span style="background-color: ${styles.backgroundColor}">${text}</span>`;
+        if (styles.textColor)
+            text = `<span style="color: ${styles.textColor}">${text}</span>`;
+        return text;
+    }
+    /**
+     * Convert a table block to HTML
+     */
+    renderTableToHtml(block) {
+        const rows = block.content || [];
+        let html = '<table>';
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            html += '<tr>';
+            const cells = Array.isArray(row) ? row : [row];
+            for (const cell of cells) {
+                const tag = i === 0 ? 'th' : 'td';
+                const cellContent = this.renderContentToHtml(cell?.content);
+                html += `<${tag}>${cellContent}</${tag}>`;
+            }
+            html += '</tr>';
+        }
+        html += '</table>';
+        return html;
+    }
+    /**
+     * Convert a block to Markdown
+     */
+    blockToMarkdown(block) {
+        const content = this.extractTextFromContent(block.content);
+        switch (block.type) {
+            case 'paragraph':
+                return content;
+            case 'heading': {
+                const level = block.props?.level || 1;
+                return `${'#'.repeat(level)} ${content}`;
+            }
+            case 'bulletListItem':
+                return `- ${content}`;
+            case 'numberedListItem':
+                return `1. ${content}`;
+            case 'checkListItem': {
+                const checked = block.props?.checked;
+                return `- [${checked ? 'x' : ' '}] ${content}`;
+            }
+            case 'quote':
+                return content.split('\n').map(line => `> ${line}`).join('\n');
+            case 'codeBlock':
+                return '```\n' + content + '\n```';
+            case 'image': {
+                const url = block.props?.url || '';
+                const caption = block.props?.caption || '';
+                return `![${caption}](${url})`;
+            }
+            case 'divider':
+                return '---';
+            default:
+                return content;
+        }
+    }
+    /**
+     * Escape HTML special characters
+     */
+    escapeHtml(text) {
+        return text
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#039;');
+    }
+    /**
+     * Sanitize filename for filesystem
+     */
+    sanitizeFilename(title) {
+        return title
+            .replace(/[^a-zA-Z0-9\s-]/g, '')
+            .replace(/\s+/g, '-')
+            .toLowerCase()
+            .substring(0, 50);
+    }
+}

package/dist/server/FilesService.d.ts

@@ -0,0 +1,44 @@
+import type { InsertFileUpload } from '../shared/types.js';
+import { DB } from './db.js';
+import { type File } from './schema.js';
+/**
+ * FilesService
+ * Handles file uploads, retrieval, and deletion
+ * Stores files as base64 encoded strings in the database
+ */
+export declare class FilesService {
+    private readonly db;
+    constructor(db: DB);
+    /**
+     * Upload a file to the database
+     * @param data - File data including filename, mimeType, size, and base64 content
+     * @returns The uploaded file record
+     * @throws Error if upload fails
+     */
+    upload(data: InsertFileUpload): Promise<File>;
+    /**
+     * Get a file by its ID
+     * @param id - The file ID
+     * @returns The file record or undefined if not found
+     */
+    getById(id: string): Promise<File | undefined>;
+    /**
+     * Delete a file by its ID
+     * @param id - The file ID to delete
+     * @throws Error if deletion fails
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * List all files with optional pagination
+     * @param options - Pagination options
+     * @returns Array of files and total count
+     */
+    list(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        files: File[];
+        total: number;
+    }>;
+}
+//# sourceMappingURL=FilesService.d.ts.map

package/dist/server/FilesService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilesService.d.ts","sourceRoot":"","sources":["../../src/server/FilesService.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAC1D,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAC5B,OAAO,EAEL,KAAK,IAAI,EACV,MAAM,aAAa,CAAA;AAEpB;;;;GAIG;AACH,qBAAa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEnC;;;;;OAKG;IACG,MAAM,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBnD;;;;OAIG;IACG,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC;IAQpD;;;;OAIG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWvC;;;;OAIG;IACG,IAAI,CAAC,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAkBzG"}

package/dist/server/FilesService.js

@@ -0,0 +1,78 @@
+import { eq, sql } from 'drizzle-orm';
+import { nanoid } from 'nanoid';
+import { filesTable } from './schema.js';
+/**
+ * FilesService
+ * Handles file uploads, retrieval, and deletion
+ * Stores files as base64 encoded strings in the database
+ */
+export class FilesService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Upload a file to the database
+     * @param data - File data including filename, mimeType, size, and base64 content
+     * @returns The uploaded file record
+     * @throws Error if upload fails
+     */
+    async upload(data) {
+        const id = nanoid();
+        const [result] = await this.db
+            .insert(filesTable)
+            .values({
+            ...data,
+            id,
+        })
+            .returning();
+        if (!result) {
+            throw new Error('Failed to upload file');
+        }
+        return result;
+    }
+    /**
+     * Get a file by its ID
+     * @param id - The file ID
+     * @returns The file record or undefined if not found
+     */
+    async getById(id) {
+        const file = await this.db.query.filesTable.findFirst({
+            where: eq(filesTable.id, id),
+        });
+        return file;
+    }
+    /**
+     * Delete a file by its ID
+     * @param id - The file ID to delete
+     * @throws Error if deletion fails
+     */
+    async delete(id) {
+        const [result] = await this.db
+            .delete(filesTable)
+            .where(eq(filesTable.id, id))
+            .returning();
+        if (!result) {
+            throw new Error('File not found');
+        }
+    }
+    /**
+     * List all files with optional pagination
+     * @param options - Pagination options
+     * @returns Array of files and total count
+     */
+    async list(options = {}) {
+        const { limit = 50, offset = 0 } = options;
+        const files = await this.db.query.filesTable.findMany({
+            limit,
+            offset,
+            orderBy: (files, { desc }) => [desc(files.createdAt)],
+        });
+        // Get total count
+        const totalResult = await this.db
+            .select({ count: sql `count(*)::int` })
+            .from(filesTable);
+        const total = Number(totalResult[0]?.count ?? 0);
+        return { files, total };
+    }
+}