@jhits/plugin-blog 0.0.19 → 0.0.20

package/dist/api/router.js

@@ -2,9 +2,6 @@
 /**
  * Plugin Blog API Router
  * Centralized API handler for all blog plugin routes
- *
- * This router handles requests to /api/plugin-blog/*
- * and routes them to the appropriate handler
  */
 import { NextResponse } from 'next/server';
 import { GET as BlogListHandler, POST as BlogCreateHandler } from './handler';
@@ -12,83 +9,59 @@ import { GET as BlogGetHandler, PUT as BlogUpdateHandler, DELETE as BlogDeleteHa
 import { GET as ConfigGetHandler, POST as ConfigPostHandler } from './config-handler';
 /**
  * Handle blog API requests
- * Routes requests to appropriate handlers based on path
- * Similar to plugin-dep, accepts config directly instead of requiring initialization
  */
 export async function handleBlogApi(req, path, config) {
-    // Create the blog API config from the router config
     const blogApiConfig = createBlogApiConfig({
         getDb: config.getDb,
         getUserId: config.getUserId,
         collectionName: config.collectionName || 'blogs',
     });
     const method = req.method;
-    // Handle empty path array - means we're at /api/plugin-blog
-    // Ensure path is always an array
     const safePath = Array.isArray(path) ? path : [];
     const route = safePath.length > 0 ? safePath[0] : '';
     try {
-        // Route: /api/plugin-blog (list/create) - empty path or 'list'
-        // This handles both /api/plugin-blog and /api/plugin-blog?limit=3
         if (!route || route === 'list') {
-            if (method === 'GET') {
+            if (method === 'GET')
                 return await BlogListHandler(req, blogApiConfig);
-            }
-            if (method === 'POST') {
+            if (method === 'POST')
                 return await BlogCreateHandler(req, blogApiConfig);
-            }
-            // Method not allowed for root route
-            return NextResponse.json({ error: `Method ${method} not allowed for route: /` }, { status: 405 });
         }
-        // Route: /api/plugin-blog/new (create new)
         else if (route === 'new') {
-            if (method === 'POST') {
+            if (method === 'POST')
                 return await BlogCreateHandler(req, blogApiConfig);
-            }
         }
-        // Route: /api/plugin-blog/categories (get categories)
         else if (route === 'categories') {
             if (method === 'GET') {
-                // Import categories handler
                 const categoriesModule = await import('./categories');
                 return await categoriesModule.GET(req, blogApiConfig);
             }
         }
-        // Route: /api/plugin-blog/check-title (check title duplicate)
         else if (route === 'check-title') {
             if (method === 'GET') {
                 const checkTitleModule = await import('./check-title');
                 return await checkTitleModule.GET(req, blogApiConfig);
             }
         }
-        // Route: /api/plugin-blog/config (get/save plugin config)
         else if (route === 'config') {
             const configApiConfig = {
                 getDb: config.getDb,
                 getUserId: config.getUserId,
                 siteId: config.siteId || 'default',
             };
-            if (method === 'GET') {
+            if (method === 'GET')
                 return await ConfigGetHandler(req, configApiConfig);
-            }
-            if (method === 'POST') {
+            if (method === 'POST')
                 return await ConfigPostHandler(req, configApiConfig);
-            }
         }
-        // Route: /api/plugin-blog/[slug] (get/update/delete by slug)
         else {
             const slug = route;
-            if (method === 'GET') {
+            if (method === 'GET')
                 return await BlogGetHandler(req, { params: Promise.resolve({ slug }) }, blogApiConfig);
-            }
-            if (method === 'PUT') {
+            if (method === 'PUT')
                 return await BlogUpdateHandler(req, { params: Promise.resolve({ slug }) }, blogApiConfig);
-            }
-            if (method === 'DELETE') {
+            if (method === 'DELETE')
                 return await BlogDeleteHandler(req, { params: Promise.resolve({ slug }) }, blogApiConfig);
-            }
         }
-        // Method not allowed
         return NextResponse.json({ error: `Method ${method} not allowed for route: ${route || '/'}` }, { status: 405 });
     }
     catch (error) {

package/dist/api/service.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Blog API Service
+ * Shared server-side logic for MongoDB operations and language fallbacks
+ */
+import { BlogApiConfig } from './handler';
+export declare class BlogService {
+    private config;
+    constructor(config: BlogApiConfig);
+    /**
+     * Common aggregation pipeline for including author data
+     */
+    private getAuthorLookupPipeline;
+    /**
+     * List blogs with filters and language fallbacks
+     */
+    listBlogs(options: {
+        limit: number;
+        skip: number;
+        status?: string;
+        isAdmin: boolean;
+        userId?: string | null;
+        requestedLanguage: string;
+    }): Promise<{
+        blogs: any;
+        total: any;
+    }>;
+    /**
+     * Get single blog by slug
+     */
+    getBlogBySlug(slug: string, requestedLanguage: string, isAdmin?: boolean): Promise<{
+        id: any;
+        slug: any;
+        title: any;
+        summary: any;
+        contentBlocks: any;
+        image: any;
+        categoryTags: {
+            category: any;
+            tags: any;
+        };
+        lang: string;
+        isMissingTranslation: boolean;
+        requestedLanguage: string;
+        availableLanguages: string[];
+        updatedAt: any;
+        languages: any;
+        status: any;
+        publication: {
+            status: any;
+            date: any;
+        };
+        author: {
+            name: any;
+            image: any;
+            displayRole: any;
+        } | undefined;
+    } | null>;
+    /**
+     * Create or update the language-specific document structure
+     */
+    prepareUpdateData(body: any, existingBlog: any | null, language: string): {
+        title: any;
+        slug: any;
+        summary: any;
+        contentBlocks: any;
+        image: any;
+        categoryTags: {
+            category: any;
+            tags: any;
+        };
+        publicationData: any;
+        languages: any;
+        updatedAt: Date;
+    };
+    /**
+     * Format a document for a specific language
+     */
+    private formatWithLanguage;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/api/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/api/service.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAG1C,qBAAa,WAAW;IACR,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAEzC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAiB/B;;OAEG;IACG,SAAS,CAAC,OAAO,EAAE;QACrB,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACvB,iBAAiB,EAAE,MAAM,CAAC;KAC7B;;;;IAiCD;;OAEG;IACG,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,OAAO,GAAE,OAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAarF;;OAEG;IACH,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG,GAAG,IAAI,EAAE,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;IAqEvE;;OAEG;IACH,OAAO,CAAC,kBAAkB;CA2E7B"}

package/dist/api/service.js

@@ -0,0 +1,219 @@
+/**
+ * Blog API Service
+ * Shared server-side logic for MongoDB operations and language fallbacks
+ */
+import { slugify } from '../lib/utils/slugify';
+export class BlogService {
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Common aggregation pipeline for including author data
+     */
+    getAuthorLookupPipeline() {
+        return [
+            {
+                $lookup: {
+                    from: 'users',
+                    let: { authorId: '$authorId' },
+                    pipeline: [
+                        { $match: { $expr: { $or: [{ $eq: ['$_id', '$$authorId'] }, { $eq: [{ $toString: '$_id' }, '$$authorId'] }] } } },
+                        { $project: { password: 0 } }
+                    ],
+                    as: 'author'
+                }
+            },
+            { $addFields: { author: { $arrayElemAt: ['$author', 0] } } }
+        ];
+    }
+    /**
+     * List blogs with filters and language fallbacks
+     */
+    async listBlogs(options) {
+        const dbConn = await this.config.getDb();
+        const db = dbConn.db();
+        const collection = db.collection(this.config.collectionName || 'blogs');
+        let query = {};
+        if (options.isAdmin && options.userId) {
+            if (options.status)
+                query = { 'publicationData.status': options.status, authorId: options.userId };
+            else
+                query = { authorId: options.userId };
+        }
+        else {
+            query = {
+                [`languages.${options.requestedLanguage}.status`]: 'published',
+                'publicationData.date': { $lte: new Date() },
+            };
+        }
+        const pipeline = [
+            { $match: query },
+            { $sort: { 'publicationData.date': -1 } },
+            { $skip: options.skip },
+            { $limit: options.isAdmin ? 1000 : options.limit },
+            ...this.getAuthorLookupPipeline()
+        ];
+        const [data, totalCount] = await Promise.all([
+            collection.aggregate(pipeline).toArray(),
+            collection.countDocuments(query),
+        ]);
+        const formatted = data.map((doc) => this.formatWithLanguage(doc, options.requestedLanguage, options.isAdmin)).filter(Boolean);
+        return { blogs: formatted, total: totalCount };
+    }
+    /**
+     * Get single blog by slug
+     */
+    async getBlogBySlug(slug, requestedLanguage, isAdmin = false) {
+        const dbConn = await this.config.getDb();
+        const db = dbConn.db();
+        const collection = db.collection(this.config.collectionName || 'blogs');
+        const pipeline = [{ $match: { slug } }, ...this.getAuthorLookupPipeline()];
+        const results = await collection.aggregate(pipeline).toArray();
+        const blog = results[0];
+        if (!blog)
+            return null;
+        return this.formatWithLanguage(blog, requestedLanguage, isAdmin);
+    }
+    /**
+     * Create or update the language-specific document structure
+     */
+    prepareUpdateData(body, existingBlog, language) {
+        const { title, summary, contentBlocks, image, categoryTags, publicationData, seo } = body;
+        const now = new Date();
+        const finalStatus = publicationData?.status || 'concept';
+        // Generate a localized slug for this specific language edition
+        // If it's not published, we add a draft suffix
+        const isPublishing = finalStatus === 'published';
+        let localizedSlug = slugify(title);
+        // Only append draft suffix if NOT publishing
+        if (!isPublishing) {
+            localizedSlug = `${localizedSlug}-draft-${Date.now().toString().slice(-4)}`;
+        }
+        const langData = {
+            blocks: contentBlocks || [],
+            metadata: {
+                title: title.trim(),
+                slug: localizedSlug, // Store the slug inside the language object
+                excerpt: (summary || '').trim(),
+                featuredImage: image,
+                categories: categoryTags?.category ? [categoryTags.category] : [],
+                tags: categoryTags?.tags || [],
+                seo: seo || {},
+            },
+            updatedAt: now.toISOString(),
+            status: finalStatus,
+        };
+        const updatedLanguages = {
+            ...(existingBlog?.languages || {}),
+            [language]: langData,
+        };
+        // Determine global status based on ALL languages
+        // If at least ONE language is published, the global status is 'published'
+        // This ensures a new draft edition doesn't hide existing published editions
+        const anyPublished = Object.values(updatedLanguages).some((l) => l.status === 'published');
+        const globalStatus = anyPublished ? 'published' : 'draft';
+        // Update root slug if this is the primary language
+        const isPrimaryLanguage = !existingBlog || language === (existingBlog.metadata?.lang || 'nl');
+        const rootSlug = isPrimaryLanguage ? localizedSlug : (existingBlog?.slug || localizedSlug);
+        return {
+            // Keep the primary title/summary but allow them to be updated
+            title: title.trim(),
+            slug: rootSlug, // Include root slug in update
+            summary: (summary || '').trim(),
+            contentBlocks: contentBlocks || [],
+            image: image || {},
+            categoryTags: {
+                category: categoryTags?.category?.trim() || '',
+                tags: categoryTags?.tags || [],
+            },
+            publicationData: {
+                ...(existingBlog?.publicationData || {}),
+                ...publicationData,
+                status: globalStatus,
+                date: publicationData?.date ? new Date(publicationData.date) : (existingBlog?.publicationData?.date || now),
+            },
+            languages: updatedLanguages,
+            updatedAt: now,
+        };
+    }
+    /**
+     * Format a document for a specific language
+     */
+    formatWithLanguage(doc, requestedLanguage, isAdmin) {
+        const languages = doc.languages || {};
+        let bestLanguage = requestedLanguage;
+        let isMissingTranslation = !languages[requestedLanguage];
+        if (isMissingTranslation && !isAdmin) {
+            const fallbacks = [doc.metadata?.lang || 'nl', 'nl', 'en'];
+            for (const lang of fallbacks) {
+                if (languages[lang]) {
+                    bestLanguage = lang;
+                    isMissingTranslation = false;
+                    break;
+                }
+            }
+            if (isMissingTranslation)
+                return null; // Public view requires translation or fallback
+        }
+        const content = languages[bestLanguage] || {};
+        const meta = content.metadata || {};
+        const status = isMissingTranslation ? 'draft' : (content.status || 'draft');
+        // --- ROBUST SLUG RESOLUTION ---
+        let resolvedSlug = doc.slug;
+        if (!isMissingTranslation) {
+            if (meta.slug) {
+                resolvedSlug = meta.slug;
+            }
+            else if (meta.title) {
+                resolvedSlug = slugify(meta.title);
+                if (status !== 'published')
+                    resolvedSlug += `-draft-${Date.now().toString().slice(-4)}`;
+            }
+        }
+        return {
+            id: doc.id || doc._id?.toString(),
+            // Prefer localized slug if available, fallback to root slug or generated one
+            slug: resolvedSlug,
+            // If missing translation, provide root content as template but keep status 'not-translated'
+            title: isMissingTranslation ? (doc.title || '') : (meta.title || doc.title || ''),
+            summary: isMissingTranslation ? (doc.summary || '') : (meta.excerpt || doc.summary || ''),
+            contentBlocks: isMissingTranslation ? (doc.contentBlocks || []) : (content.blocks || doc.contentBlocks || []),
+            image: isMissingTranslation ? doc.image : (meta.featuredImage || doc.image),
+            categoryTags: isMissingTranslation ? { category: '', tags: [] } : {
+                category: meta.categories?.[0] || '',
+                tags: meta.tags || []
+            },
+            lang: bestLanguage,
+            isMissingTranslation,
+            requestedLanguage,
+            availableLanguages: Object.keys(languages),
+            updatedAt: doc.updatedAt || doc.publicationData?.date || new Date().toISOString(),
+            // Include a lightweight summary of all languages for admin view (tooltips)
+            languages: isAdmin ? (() => {
+                const summary = {};
+                // Use Object.keys(languages) to ensure we iterate over all existing translations
+                Object.keys(languages).forEach(lang => {
+                    const lData = languages[lang] || {};
+                    // Normalize status: handle 'concept' -> 'draft'
+                    let langStatus = lData.status || 'draft';
+                    if (langStatus === 'concept')
+                        langStatus = 'draft';
+                    summary[lang] = {
+                        status: langStatus,
+                        metadata: {
+                            title: lData.metadata?.title || doc.title || 'Untitled'
+                        }
+                    };
+                });
+                return summary;
+            })() : undefined,
+            status: status,
+            publication: {
+                status: status,
+                // FORCE undefined date for new editions so they don't look published or inherit old dates
+                date: isMissingTranslation ? undefined : (doc.publicationData?.date || doc.updatedAt)
+            },
+            author: doc.author ? { name: doc.author.name, image: doc.author.image, displayRole: doc.author.displayRole } : undefined
+        };
+    }
+}

package/dist/hooks/useAutoSave.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Hook for automatic saving of editor state
+ */
+export declare function useAutoSave(postId: string | undefined, state: any, onSave: (state: any) => Promise<void>, delay?: number): {
+    autoSaveEnabled: boolean;
+    setAutoSaveEnabled: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    saveStatus: "error" | "idle" | "saving" | "saved";
+    countdown: number | null;
+};
+//# sourceMappingURL=useAutoSave.d.ts.map

package/dist/hooks/useAutoSave.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAutoSave.d.ts","sourceRoot":"","sources":["../../src/hooks/useAutoSave.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,wBAAgB,WAAW,CACvB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,KAAK,EAAE,GAAG,EACV,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,EACrC,KAAK,SAAQ;;;;;EAoDhB"}

package/dist/hooks/useAutoSave.js

@@ -0,0 +1,57 @@
+'use client';
+import { useState, useEffect, useRef } from 'react';
+/**
+ * Hook for automatic saving of editor state
+ */
+export function useAutoSave(postId, state, onSave, delay = 10000) {
+    const [autoSaveEnabled, setAutoSaveEnabled] = useState(true);
+    const [saveStatus, setSaveStatus] = useState('idle');
+    const [countdown, setCountdown] = useState(null);
+    const timerRef = useRef(null);
+    const countdownIntervalRef = useRef(null);
+    useEffect(() => {
+        if (!autoSaveEnabled || !state.isDirty || !postId) {
+            setCountdown(null);
+            if (timerRef.current)
+                clearTimeout(timerRef.current);
+            if (countdownIntervalRef.current)
+                clearInterval(countdownIntervalRef.current);
+            return;
+        }
+        // Reset timer on state change
+        if (timerRef.current)
+            clearTimeout(timerRef.current);
+        if (countdownIntervalRef.current)
+            clearInterval(countdownIntervalRef.current);
+        const startTime = Date.now();
+        setCountdown(Math.ceil(delay / 1000));
+        countdownIntervalRef.current = setInterval(() => {
+            const remaining = Math.max(0, delay - (Date.now() - startTime));
+            setCountdown(Math.ceil(remaining / 1000));
+        }, 1000);
+        timerRef.current = setTimeout(async () => {
+            setSaveStatus('saving');
+            try {
+                await onSave(state);
+                setSaveStatus('saved');
+                setTimeout(() => setSaveStatus('idle'), 2000);
+            }
+            catch (error) {
+                setSaveStatus('error');
+                setTimeout(() => setSaveStatus('idle'), 3000);
+            }
+        }, delay);
+        return () => {
+            if (timerRef.current)
+                clearTimeout(timerRef.current);
+            if (countdownIntervalRef.current)
+                clearInterval(countdownIntervalRef.current);
+        };
+    }, [state, autoSaveEnabled, postId, delay, onSave]);
+    return {
+        autoSaveEnabled,
+        setAutoSaveEnabled,
+        saveStatus,
+        countdown
+    };
+}

package/dist/hooks/useCategories.d.ts

@@ -2,7 +2,7 @@
  * Hook to fetch categories from existing blog posts
  * Extracts categories from Hero blocks in all posts
  */
-export declare function useCategories(): {
+export declare function useCategories(language?: string): {
     categories: string[];
     loading: boolean;
 };

package/dist/hooks/useCategories.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCategories.d.ts","sourceRoot":"","sources":["../../src/hooks/useCategories.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,wBAAgB,aAAa;;;EAkE5B"}
+{"version":3,"file":"useCategories.d.ts","sourceRoot":"","sources":["../../src/hooks/useCategories.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,wBAAgB,aAAa,CAAC,QAAQ,CAAC,EAAE,MAAM;;;EAsC9C"}

package/dist/hooks/useCategories.js

@@ -4,60 +4,29 @@
  */
 'use client';
 import { useState, useEffect } from 'react';
-export function useCategories() {
+export function useCategories(language) {
     const [categories, setCategories] = useState([]);
     const [loading, setLoading] = useState(true);
     useEffect(() => {
         const fetchCategories = async () => {
             try {
-                const categorySet = new Set();
-                // 1. Fetch from categories endpoint (legacy categoryTags.category)
-                try {
-                    const categoriesResponse = await fetch('/api/plugin-blog/categories');
-                    if (categoriesResponse.ok) {
-                        const categoriesData = await categoriesResponse.json();
-                        if (Array.isArray(categoriesData.categories)) {
-                            categoriesData.categories.forEach((cat) => {
-                                if (cat && cat.trim()) {
-                                    categorySet.add(cat.trim());
-                                }
-                            });
-                        }
-                    }
+                // We rely on the specialized categories endpoint which is strictly filtered by the Orchestrator
+                const url = language
+                    ? `/api/plugin-blog/categories?language=${language}`
+                    : '/api/plugin-blog/categories';
+                const response = await fetch(url);
+                if (response.ok) {
+                    const data = await response.json();
+                    const list = Array.isArray(data.categories) ? data.categories : [];
+                    setCategories(list);
                 }
-                catch (e) {
-                    // Categories endpoint not available, continue
+                else {
+                    console.error(`[useCategories] API_ERROR: ${response.status}`);
+                    setCategories([]);
                 }
-                // 2. Fetch all blog posts and extract categories from Hero blocks
-                try {
-                    const response = await fetch('/api/plugin-blog?admin=true&limit=1000');
-                    if (response.ok) {
-                        const data = await response.json();
-                        const posts = Array.isArray(data.blogs) ? data.blogs : (Array.isArray(data) ? data : []);
-                        posts.forEach((post) => {
-                            if (post.blocks && Array.isArray(post.blocks)) {
-                                // Find Hero block
-                                const heroBlock = post.blocks.find((block) => block.type === 'hero');
-                                if (heroBlock && heroBlock.data && heroBlock.data.category) {
-                                    const category = heroBlock.data.category.trim();
-                                    if (category) {
-                                        categorySet.add(category);
-                                    }
-                                }
-                            }
-                        });
-                    }
-                }
-                catch (e) {
-                    console.error('Failed to fetch posts for categories:', e);
-                }
-                // Convert to sorted array
-                const sortedCategories = Array.from(categorySet).sort();
-                setCategories(sortedCategories);
             }
             catch (error) {
-                console.error('Failed to fetch categories:', error);
-                // Fallback to empty array
+                console.error('[useCategories] CRITICAL_SYNC_FAILURE:', error);
                 setCategories([]);
             }
             finally {
@@ -65,6 +34,6 @@ export function useCategories() {
             }
         };
         fetchCategories();
-    }, []);
+    }, [language]);
     return { categories, loading };
 }

package/dist/index.d.ts

@@ -1,55 +1,48 @@
 /**
  * Plugin Blog - Main Entry Point
- * Block-Based Blog Management System
- * Multi-Tenant Architecture: Accepts custom blocks from client applications
+ * Simplified with Configuration Resolver
  */
+import React from 'react';
 import { ClientBlockDefinition } from './types/block';
-/**
- * Plugin Props Interface
- * Matches the PluginProps from @jhits/jhits-dashboard
- */
 export interface PluginProps {
     subPath: string[];
     siteId: string;
     locale: string;
-    /** Custom blocks from client application (optional, can also come from window.__JHITS_PLUGIN_PROPS__) */
     customBlocks?: ClientBlockDefinition[];
-    /** Enable dark mode for content area and wrappers (default: true) */
     darkMode?: boolean;
-    /** Background colors for the editor */
     backgroundColors?: {
-        /** Background color for light mode (REQUIRED) */
         light: string;
-        /** Background color for dark mode (optional) */
         dark?: string;
     };
+    LayoutWrapper?: React.ComponentType<any>;
+    translations?: Record<string, any>;
 }
 /**
- * Main Router Component
- * Handles routing within the blog plugin
- *
- * Client Handshake:
- * - Client apps can pass customBlocks via props
- * - Or via window.__JHITS_PLUGIN_PROPS__['plugin-blog'].customBlocks
- * - The EditorProvider will automatically register these blocks
+ * Client-facing configuration type
+ * Allows partial overrides of plugin behavior
  */
+export type BlogPluginConfig = Partial<Omit<PluginProps, 'subPath' | 'siteId' | 'locale'>> & {
+    customBlocks?: ClientBlockDefinition[];
+    darkMode?: boolean;
+    backgroundColors?: {
+        light: string;
+        dark?: string;
+    };
+    LayoutWrapper?: React.ComponentType<any>;
+    translations?: Record<string, any>;
+};
 export default function BlogPlugin(props: PluginProps): import("react/jsx-runtime").JSX.Element;
 export { BlogPlugin as Index };
-export type { Block, BlockTypeDefinition, ClientBlockDefinition, RichTextFormattingConfig, BlockEditProps, BlockPreviewProps, IBlockComponent, } from './types';
-export type { SEOMetadata, PublicationData, PostStatus, PostMetadata, BlogPost, PostListItem, PostFilterOptions, BlogPostLanguageContent, BlogPostLanguages, } from './types/post';
+export type { Block, ClientBlockDefinition, BlockEditProps, BlockPreviewProps, BlockTypeDefinition, IBlockComponent } from './types';
+export type { SEOMetadata, PublicationData, BlogPost, PostListItem, PostStatus } from './types';
 export { initBlogPlugin } from './init';
-export type { BlogPluginConfig } from './init';
 export { RichTextEditor, RichTextPreview } from './lib/rich-text';
-export type { RichTextEditorProps, RichTextPreviewProps } from './lib/rich-text';
-export { useBlogs, useBlog } from './hooks';
-export type { UseBlogsOptions, UseBlogsResult, UseBlogOptions, UseBlogResult } from './hooks';
-export { fetchBlogs, fetchBlog } from './utils/client';
-export type { FetchBlogsOptions, FetchBlogsResult, FetchBlogOptions } from './utils/client';
-export { BlockRenderer, BlocksRenderer } from './lib/blocks/BlockRenderer';
+export { useBlogs, useBlog, useCategories } from './hooks';
 export { blockRegistry } from './registry';
-export { registerLayoutBlocks } from './lib/layouts/registerLayoutBlocks';
-export { getPluginConfig, savePluginConfig } from './lib/config-storage';
 export { EditorProvider, useEditor } from './state/EditorContext';
-export type { EditorProviderProps, EditorState, EditorContextValue } from './state';
-export { useCategories } from './hooks/useCategories';
+export type { EditorProviderProps } from './state/EditorContext';
+export type { EditorState, EditorContextValue } from './state/types';
+export { BlockRenderer, BlocksRenderer } from './lib/blocks/BlockRenderer';
+export { ColumnsPreview } from './lib/layouts/blocks/ColumnsBlock';
+export { registerLayoutBlocks } from './lib/layouts/registerLayoutBlocks';
 //# sourceMappingURL=index.d.ts.map