@jhits/plugin-blog 0.0.8 → 0.0.9

package/src/lib/rich-text/RichTextPreview.js

@@ -0,0 +1,144 @@
+/**
+ * Rich Text Preview Component
+ * Renders HTML content with client-provided styles
+ * Also supports plain text with formatting markers using the plugin-content parser
+ */
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { parse, useParserConfig } from '@jhits/plugin-content';
+/**
+ * Check if content is HTML or plain text with formatting markers
+ */
+function isHtmlContent(content) {
+    // If content contains HTML tags, it's HTML
+    if (/<[a-z][\s\S]*>/i.test(content)) {
+        return true;
+    }
+    // If content contains HTML entities, it's likely HTML
+    if (/&[a-z]+;/i.test(content)) {
+        return true;
+    }
+    // Otherwise, it's plain text (potentially with formatting markers)
+    return false;
+}
+export function RichTextPreview({ content, formatting, className = '', }) {
+    // Handle empty content
+    if (!content || content.trim() === '') {
+        return _jsx("div", { className: className, children: "\u00A0" });
+    }
+    // Get parser config from context (provided by client app)
+    const parserConfig = useParserConfig();
+    // Check if content is HTML or plain text
+    const isHtml = isHtmlContent(content);
+    // If it's plain text, use the parser from plugin-content
+    if (!isHtml) {
+        const parsedContent = parse(content, false, parserConfig);
+        return (_jsx("div", { className: className, children: parsedContent }));
+    }
+    // Otherwise, continue with HTML rendering logic
+    // Apply client-provided styles to HTML content
+    const applyStyles = (html) => {
+        if (!(formatting === null || formatting === void 0 ? void 0 : formatting.styles))
+            return html;
+        const styles = formatting.styles;
+        let styledHtml = html;
+        // Apply bold style - handle both <strong> and <b> tags
+        if (styles.bold) {
+            // Replace <strong> tags
+            styledHtml = styledHtml.replace(/<strong\b([^>]*)>/gi, (match, attrs) => {
+                // Check if class already exists
+                if (attrs && attrs.includes('class=')) {
+                    return match.replace(/class="([^"]*)"/, `class="$1 ${styles.bold}"`);
+                }
+                return `<strong class="${styles.bold}">`;
+            });
+            // Replace <b> tags
+            styledHtml = styledHtml.replace(/<b\b([^>]*)>/gi, (match, attrs) => {
+                if (attrs && attrs.includes('class=')) {
+                    return match.replace(/class="([^"]*)"/, `class="$1 ${styles.bold}"`);
+                }
+                return `<b class="${styles.bold}">`;
+            });
+        }
+        // Apply italic style - handle both <em> and <i> tags
+        if (styles.italic) {
+            styledHtml = styledHtml.replace(/<em\b([^>]*)>/gi, (match, attrs) => {
+                if (attrs && attrs.includes('class=')) {
+                    return match.replace(/class="([^"]*)"/, `class="$1 ${styles.italic}"`);
+                }
+                return `<em class="${styles.italic}">`;
+            });
+            styledHtml = styledHtml.replace(/<i\b([^>]*)>/gi, (match, attrs) => {
+                if (attrs && attrs.includes('class=')) {
+                    return match.replace(/class="([^"]*)"/, `class="$1 ${styles.italic}"`);
+                }
+                return `<i class="${styles.italic}">`;
+            });
+        }
+        // Apply underline style
+        if (styles.underline) {
+            styledHtml = styledHtml.replace(/<u\b([^>]*)>/gi, (match, attrs) => {
+                if (attrs && attrs.includes('class=')) {
+                    return match.replace(/class="([^"]*)"/, `class="$1 ${styles.underline}"`);
+                }
+                return `<u class="${styles.underline}">`;
+            });
+        }
+        // Apply link style
+        if (styles.link) {
+            styledHtml = styledHtml.replace(/<a\b([^>]*)>/gi, (match, attrs) => {
+                if (attrs && attrs.includes('class=')) {
+                    return match.replace(/class="([^"]*)"/, `class="$1 ${styles.link}"`);
+                }
+                return match.replace('>', ` class="${styles.link}">`);
+            });
+        }
+        // Apply color classes to spans (preserve existing classes)
+        if (styles.colorClasses) {
+            Object.entries(styles.colorClasses).forEach(([color, colorClass]) => {
+                // Match spans that might have the color class already or need it added
+                const regex = new RegExp(`<span([^>]*)class="([^"]*)"([^>]*)>`, 'gi');
+                styledHtml = styledHtml.replace(regex, (match, beforeAttrs, existingClasses, afterAttrs) => {
+                    // Don't add if class already exists
+                    if (existingClasses.includes(colorClass)) {
+                        return match;
+                    }
+                    // Add the color class
+                    return `<span${beforeAttrs}class="${existingClasses} ${colorClass}"${afterAttrs}>`;
+                });
+                // Also handle spans without class attribute
+                const regexNoClass = new RegExp(`<span([^>]*)>`, 'gi');
+                styledHtml = styledHtml.replace(regexNoClass, (match, attrs) => {
+                    // Only add if this span doesn't already have a class and we're looking for a specific color
+                    if (!attrs.includes('class=')) {
+                        return match.replace('>', ` class="${colorClass}">`);
+                    }
+                    return match;
+                });
+            });
+        }
+        return styledHtml;
+    };
+    const styledContent = formatting ? applyStyles(content) : content;
+    // For rendering, we'll use a ref to set innerHTML only on the client side
+    // This avoids SSR issues while still allowing HTML rendering
+    const contentRef = React.useRef(null);
+    React.useEffect(() => {
+        if (contentRef.current && styledContent) {
+            contentRef.current.innerHTML = styledContent;
+        }
+    }, [styledContent]);
+    // For server-side rendering, render plain text
+    if (typeof window === 'undefined') {
+        const textContent = styledContent
+            .replace(/<[^>]*>/g, '')
+            .replace(/&nbsp;/g, ' ')
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"');
+        return (_jsx("div", { className: className, children: textContent || '\u00A0' }));
+    }
+    return (_jsx("div", { ref: contentRef, className: className }));
+}

package/src/lib/rich-text/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Rich Text Utilities
+ * Export rich text editor and preview components
+ */
+export { RichTextEditor } from './RichTextEditor';
+export { RichTextPreview } from './RichTextPreview';
+export type { RichTextFormattingConfig, RichTextEditorProps } from './RichTextEditor';
+export type { RichTextPreviewProps } from './RichTextPreview';
+//# sourceMappingURL=index.d.ts.map

package/src/lib/rich-text/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,YAAY,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACtF,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC"}

package/src/lib/rich-text/index.js

@@ -0,0 +1,6 @@
+/**
+ * Rich Text Utilities
+ * Export rich text editor and preview components
+ */
+export { RichTextEditor } from './RichTextEditor';
+export { RichTextPreview } from './RichTextPreview';

package/src/lib/utils/blockHelpers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Block Helper Utilities
+ * Functions for working with blocks, including nested structures
+ */
+import { Block } from '../../types/block';
+/**
+ * Get child blocks from a container block
+ * Handles both Block[] and string[] formats
+ */
+export declare function getChildBlocks(block: Block, allBlocks?: Block[]): Block[];
+/**
+ * Check if a block is a container (has children or is marked as container)
+ */
+export declare function isContainerBlock(block: Block, blockRegistry: {
+    get: (type: string) => {
+        isContainer?: boolean;
+    } | undefined;
+}): boolean;
+/**
+ * Find a block by ID recursively (including nested blocks)
+ */
+export declare function findBlockById(blocks: Block[], id: string): Block | null;
+//# sourceMappingURL=blockHelpers.d.ts.map

package/src/lib/utils/blockHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockHelpers.d.ts","sourceRoot":"","sources":["blockHelpers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE1C;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,GAAE,KAAK,EAAO,GAAG,KAAK,EAAE,CAiC7E;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE;IAAE,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK;QAAE,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAA;CAAE,GAAG,OAAO,CAGvI;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,CAavE"}

package/src/lib/utils/blockHelpers.js

@@ -0,0 +1,65 @@
+/**
+ * Block Helper Utilities
+ * Functions for working with blocks, including nested structures
+ */
+/**
+ * Get child blocks from a container block
+ * Handles both Block[] and string[] formats
+ */
+export function getChildBlocks(block, allBlocks = []) {
+    if (!block.children || block.children.length === 0) {
+        return [];
+    }
+    // If children are Block objects, return them directly
+    if (block.children.length > 0 && typeof block.children[0] === 'object' && 'id' in block.children[0]) {
+        return block.children;
+    }
+    // If children are IDs, resolve them from allBlocks (recursively search nested blocks)
+    const childIds = block.children;
+    const resolvedBlocks = [];
+    function findBlockRecursive(blocks, id) {
+        for (const b of blocks) {
+            if (b.id === id)
+                return b;
+            if (b.children && Array.isArray(b.children) && b.children.length > 0) {
+                if (typeof b.children[0] === 'object') {
+                    const found = findBlockRecursive(b.children, id);
+                    if (found)
+                        return found;
+                }
+            }
+        }
+        return null;
+    }
+    childIds.forEach(id => {
+        const found = findBlockRecursive(allBlocks, id);
+        if (found)
+            resolvedBlocks.push(found);
+    });
+    return resolvedBlocks;
+}
+/**
+ * Check if a block is a container (has children or is marked as container)
+ */
+export function isContainerBlock(block, blockRegistry) {
+    const definition = blockRegistry.get(block.type);
+    return (definition === null || definition === void 0 ? void 0 : definition.isContainer) === true || (block.children !== undefined && block.children.length > 0);
+}
+/**
+ * Find a block by ID recursively (including nested blocks)
+ */
+export function findBlockById(blocks, id) {
+    for (const block of blocks) {
+        if (block.id === id) {
+            return block;
+        }
+        if (block.children && Array.isArray(block.children) && block.children.length > 0) {
+            if (typeof block.children[0] === 'object') {
+                const found = findBlockById(block.children, id);
+                if (found)
+                    return found;
+            }
+        }
+    }
+    return null;
+}

package/src/lib/utils/configValidation.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Plugin Configuration Validation Utilities
+ * Validates plugin configuration and custom blocks
+ */
+import { ClientBlockDefinition } from '../../types/block';
+/**
+ * Check if a route requires the hero block
+ */
+export declare function routeRequiresHeroBlock(route: string): boolean;
+/**
+ * Find hero block definition in custom blocks
+ */
+export declare function findHeroBlock(customBlocks: ClientBlockDefinition[]): ClientBlockDefinition | undefined;
+/**
+ * Hook to validate hero block configuration
+ * Only validates for routes that require it, and waits for customBlocks to load
+ *
+ * @param route - Current route (e.g., 'posts', 'editor', 'new')
+ * @param customBlocks - Array of custom block definitions
+ * @param propsCustomBlocks - Custom blocks from props (for immediate validation)
+ */
+export declare function useHeroBlockValidation(route: string, customBlocks: ClientBlockDefinition[], propsCustomBlocks?: ClientBlockDefinition[]): void;
+//# sourceMappingURL=configValidation.d.ts.map

package/src/lib/utils/configValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configValidation.d.ts","sourceRoot":"","sources":["configValidation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAO1D;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,YAAY,EAAE,qBAAqB,EAAE,GAAG,qBAAqB,GAAG,SAAS,CAEtG;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAClC,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,qBAAqB,EAAE,EACrC,iBAAiB,CAAC,EAAE,qBAAqB,EAAE,GAC5C,IAAI,CAgGN"}

package/src/lib/utils/configValidation.js

@@ -0,0 +1,113 @@
+/**
+ * Plugin Configuration Validation Utilities
+ * Validates plugin configuration and custom blocks
+ */
+import { useEffect, useState, useMemo } from 'react';
+/**
+ * Routes that require the hero block to be defined
+ */
+const ROUTES_REQUIRING_HERO_BLOCK = ['editor', 'new', 'preview'];
+/**
+ * Check if a route requires the hero block
+ */
+export function routeRequiresHeroBlock(route) {
+    return ROUTES_REQUIRING_HERO_BLOCK.includes(route);
+}
+/**
+ * Find hero block definition in custom blocks
+ */
+export function findHeroBlock(customBlocks) {
+    return customBlocks.find(block => block.type === 'hero');
+}
+/**
+ * Hook to validate hero block configuration
+ * Only validates for routes that require it, and waits for customBlocks to load
+ *
+ * @param route - Current route (e.g., 'posts', 'editor', 'new')
+ * @param customBlocks - Array of custom block definitions
+ * @param propsCustomBlocks - Custom blocks from props (for immediate validation)
+ */
+export function useHeroBlockValidation(route, customBlocks, propsCustomBlocks) {
+    const needsHeroBlock = useMemo(() => routeRequiresHeroBlock(route), [route]);
+    const heroBlockDefinition = useMemo(() => {
+        // Only search for hero block if route needs it
+        return needsHeroBlock ? findHeroBlock(customBlocks) : undefined;
+    }, [customBlocks, needsHeroBlock]);
+    // Track if we've given customBlocks time to load from window global
+    // This prevents false errors when customBlocks are loaded asynchronously
+    // Only track this if we actually need the hero block
+    const [hasCheckedForBlocks, setHasCheckedForBlocks] = useState(false);
+    // Give window global a chance to load before validating
+    // Only do this if the route needs the hero block
+    useEffect(() => {
+        var _a, _b;
+        // Early return: Skip all validation logic if route doesn't need hero block
+        if (!needsHeroBlock) {
+            return;
+        }
+        if (typeof window === 'undefined') {
+            setHasCheckedForBlocks(true); // Server-side, no need to wait
+            return;
+        }
+        // If props are provided, we can validate immediately
+        if (propsCustomBlocks && propsCustomBlocks.length > 0) {
+            setHasCheckedForBlocks(true);
+            return;
+        }
+        // Check if window global is already available
+        if ((_b = (_a = window.__JHITS_PLUGIN_PROPS__) === null || _a === void 0 ? void 0 : _a['plugin-blog']) === null || _b === void 0 ? void 0 : _b.customBlocks) {
+            setHasCheckedForBlocks(true);
+            return;
+        }
+        // Retry mechanism: check multiple times with increasing delays
+        // This handles the case where BlogPluginInit's useEffect runs after BlogPlugin mounts
+        // BlogPluginInit runs initBlogPlugin in useEffect, which may execute after BlogPlugin's first render
+        let attempt = 0;
+        const maxAttempts = 6;
+        const delays = [50, 100, 200, 300, 500, 1000]; // Progressive delays: total ~2.15s
+        const timers = [];
+        const checkWithRetry = () => {
+            var _a, _b;
+            const windowGlobal = (_b = (_a = window.__JHITS_PLUGIN_PROPS__) === null || _a === void 0 ? void 0 : _a['plugin-blog']) === null || _b === void 0 ? void 0 : _b.customBlocks;
+            if (windowGlobal && windowGlobal.length > 0) {
+                // Found it! Mark as checked
+                setHasCheckedForBlocks(true);
+                return;
+            }
+            if (attempt < maxAttempts) {
+                const timer = setTimeout(() => {
+                    attempt++;
+                    checkWithRetry();
+                }, delays[attempt]);
+                timers.push(timer);
+            }
+            else {
+                // After all retries, mark as checked (even if not found)
+                // This prevents infinite waiting and allows validation to proceed
+                setHasCheckedForBlocks(true);
+            }
+        };
+        // Start checking
+        checkWithRetry();
+        // Cleanup all timers
+        return () => {
+            timers.forEach(timer => clearTimeout(timer));
+        };
+    }, [propsCustomBlocks, needsHeroBlock]);
+    // Validate that Hero block is required (only for editor routes, and only after we've checked for blocks)
+    useEffect(() => {
+        // Early return if route doesn't need hero block - no validation needed
+        if (!needsHeroBlock) {
+            return;
+        }
+        // Only validate if:
+        // 1. We're in a route that needs the hero block (already checked above)
+        // 2. We've given customBlocks time to load (hasCheckedForBlocks is true)
+        // 3. The hero block is still not found
+        if (hasCheckedForBlocks && !heroBlockDefinition) {
+            console.error('[BlogPlugin] Hero block is REQUIRED but not found in customBlocks. ' +
+                'Please define a block with type: "hero" in your blog config. ' +
+                `Current route: "${route}"`);
+        }
+    }, [heroBlockDefinition, needsHeroBlock, hasCheckedForBlocks, route]);
+}

package/src/registry/BlockRegistry.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Block Registry
+ * Dynamic registry for all block types in the system
+ * Multi-Tenant Architecture: Blocks are provided by client applications
+ *
+ * The registry is a singleton that starts empty and is populated by client apps
+ */
+import { BlockTypeDefinition, BlockRegistry as IBlockRegistry, ClientBlockDefinition } from '../types/block';
+/**
+ * Dynamic Block Registry Implementation
+ * No default blocks - all blocks must be registered by client applications
+ */
+declare class BlockRegistryImpl implements IBlockRegistry {
+    private _types;
+    get types(): Map<string, BlockTypeDefinition>;
+    /**
+     * Register a single block type
+     */
+    register(definition: BlockTypeDefinition): void;
+    /**
+     * Register multiple client blocks at once
+     * This is the primary method for client applications to register their blocks
+     */
+    registerClientBlocks(definitions: ClientBlockDefinition[]): void;
+    /**
+     * Get block type definition by type string
+     */
+    get(type: string): BlockTypeDefinition | undefined;
+    /**
+     * Get all registered block types
+     */
+    getAll(): BlockTypeDefinition[];
+    /**
+     * Get block types filtered by category
+     */
+    getByCategory(category: BlockTypeDefinition['category']): BlockTypeDefinition[];
+    /**
+     * Check if a block type is registered
+     */
+    has(type: string): boolean;
+    /**
+     * Unregister a block type (useful for testing or dynamic loading)
+     */
+    unregister(type: string): boolean;
+    /**
+     * Clear all registered block types
+     * Useful for testing or resetting the registry
+     */
+    clear(): void;
+    /**
+     * Get count of registered blocks
+     */
+    getCount(): number;
+}
+export declare const blockRegistry: BlockRegistryImpl;
+export {};
+/**
+ * NOTE: No default blocks are registered automatically.
+ * Client applications must call registerClientBlocks() to populate the registry.
+ * This ensures the editor is a true "shell" without hardcoded blocks.
+ */
+//# sourceMappingURL=BlockRegistry.d.ts.map

package/src/registry/BlockRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockRegistry.d.ts","sourceRoot":"","sources":["BlockRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACH,mBAAmB,EACnB,aAAa,IAAI,cAAc,EAC/B,qBAAqB,EACxB,MAAM,gBAAgB,CAAC;AAExB;;;GAGG;AACH,cAAM,iBAAkB,YAAW,cAAc;IAC7C,OAAO,CAAC,MAAM,CAA+C;IAE7D,IAAI,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAE5C;IAED;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,mBAAmB,GAAG,IAAI;IAa/C;;;OAGG;IACH,oBAAoB,CAAC,WAAW,EAAE,qBAAqB,EAAE,GAAG,IAAI;IAmChE;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAIlD;;OAEG;IACH,MAAM,IAAI,mBAAmB,EAAE;IAI/B;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,mBAAmB,CAAC,UAAU,CAAC,GAAG,mBAAmB,EAAE;IAI/E;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIjC;;;OAGG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,QAAQ,IAAI,MAAM;CAGrB;AAGD,eAAO,MAAM,aAAa,mBAA0B,CAAC;;AAErD;;;;GAIG"}

package/src/registry/BlockRegistry.js

@@ -0,0 +1,112 @@
+/**
+ * Block Registry
+ * Dynamic registry for all block types in the system
+ * Multi-Tenant Architecture: Blocks are provided by client applications
+ *
+ * The registry is a singleton that starts empty and is populated by client apps
+ */
+/**
+ * Dynamic Block Registry Implementation
+ * No default blocks - all blocks must be registered by client applications
+ */
+class BlockRegistryImpl {
+    constructor() {
+        this._types = new Map();
+    }
+    get types() {
+        return this._types;
+    }
+    /**
+     * Register a single block type
+     */
+    register(definition) {
+        // Validate that components are provided
+        if (!definition.components || !definition.components.Edit || !definition.components.Preview) {
+            throw new Error(`Block type "${definition.type}" must provide both Edit and Preview components. ` +
+                `Use registerClientBlocks() for client-provided blocks.`);
+        }
+        // Silently overwrite if already registered (expected in React 18 Strict Mode)
+        this._types.set(definition.type, definition);
+    }
+    /**
+     * Register multiple client blocks at once
+     * This is the primary method for client applications to register their blocks
+     */
+    registerClientBlocks(definitions) {
+        for (const def of definitions) {
+            // Validate required fields
+            if (!def.type || !def.name || !def.components) {
+                console.error('Invalid block definition:', def);
+                throw new Error('Block definition must have: type, name, and components (with Edit and Preview)');
+            }
+            // Validate components
+            if (!def.components.Edit || !def.components.Preview) {
+                throw new Error(`Block "${def.type}" must provide both Edit and Preview components in the components object`);
+            }
+            // Convert ClientBlockDefinition to BlockTypeDefinition
+            const blockDefinition = {
+                type: def.type,
+                name: def.name,
+                description: def.description,
+                icon: def.icon || def.components.Icon,
+                defaultData: def.defaultData,
+                validate: def.validate,
+                isContainer: def.isContainer,
+                allowedChildren: def.allowedChildren,
+                category: def.category || 'custom',
+                components: def.components,
+            };
+            this.register(blockDefinition);
+        }
+    }
+    /**
+     * Get block type definition by type string
+     */
+    get(type) {
+        return this._types.get(type);
+    }
+    /**
+     * Get all registered block types
+     */
+    getAll() {
+        return Array.from(this._types.values());
+    }
+    /**
+     * Get block types filtered by category
+     */
+    getByCategory(category) {
+        return this.getAll().filter(block => block.category === category);
+    }
+    /**
+     * Check if a block type is registered
+     */
+    has(type) {
+        return this._types.has(type);
+    }
+    /**
+     * Unregister a block type (useful for testing or dynamic loading)
+     */
+    unregister(type) {
+        return this._types.delete(type);
+    }
+    /**
+     * Clear all registered block types
+     * Useful for testing or resetting the registry
+     */
+    clear() {
+        this._types.clear();
+    }
+    /**
+     * Get count of registered blocks
+     */
+    getCount() {
+        return this._types.size;
+    }
+}
+// Singleton instance - starts empty, populated by client apps
+export const blockRegistry = new BlockRegistryImpl();
+/**
+ * NOTE: No default blocks are registered automatically.
+ * Client applications must call registerClientBlocks() to populate the registry.
+ * This ensures the editor is a true "shell" without hardcoded blocks.
+ */

package/src/registry/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Registry exports
+ */
+export { blockRegistry } from './BlockRegistry';
+export type { ClientBlockDefinition, BlockTypeDefinition, BlockRegistry, } from '../types/block';
+//# sourceMappingURL=index.d.ts.map

package/src/registry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,YAAY,EACR,qBAAqB,EACrB,mBAAmB,EACnB,aAAa,GAChB,MAAM,gBAAgB,CAAC"}

package/src/registry/index.js

@@ -0,0 +1,4 @@
+/**
+ * Registry exports
+ */
+export { blockRegistry } from './BlockRegistry';

package/src/state/EditorContext.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Editor Context
+ * React Context for managing editor state
+ * Multi-Tenant: Accepts custom blocks from client applications
+ */
+import React from 'react';
+import { EditorContextValue, EditorState } from './types';
+import { Block } from '../types/block';
+import { ClientBlockDefinition } from '../types/block';
+/**
+ * Editor Provider Props
+ */
+export interface EditorProviderProps {
+    children: React.ReactNode;
+    /** Initial state (optional) */
+    initialState?: Partial<EditorState>;
+    /** Callback when save is triggered */
+    onSave?: (state: EditorState, heroBlock?: Block | null) => Promise<void>;
+    /**
+     * Custom blocks from client application
+     * These blocks will be registered in the BlockRegistry on mount
+     */
+    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;
+    };
+}
+/**
+ * Editor Provider
+ * Provides editor state and actions to child components
+ * Automatically registers client-provided blocks on mount
+ */
+export declare function EditorProvider({ children, initialState, onSave, customBlocks, darkMode, backgroundColors }: EditorProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access editor context
+ * @throws Error if used outside EditorProvider
+ */
+export declare function useEditor(): EditorContextValue;
+//# sourceMappingURL=EditorContext.d.ts.map

package/src/state/EditorContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditorContext.d.ts","sourceRoot":"","sources":["EditorContext.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAmG,MAAM,OAAO,CAAC;AAExH,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAoC,MAAM,SAAS,CAAC;AAC5F,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAGvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAMvD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,+BAA+B;IAC/B,YAAY,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IACpC,sCAAsC;IACtC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,SAAS,CAAC,EAAE,KAAK,GAAG,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACzE;;;OAGG;IACH,YAAY,CAAC,EAAE,qBAAqB,EAAE,CAAC;IACvC,qEAAqE;IACrE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uCAAuC;IACvC,gBAAgB,CAAC,EAAE;QACf,iDAAiD;QACjD,KAAK,EAAE,MAAM,CAAC;QACd,gDAAgD;QAChD,IAAI,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,EAC3B,QAAQ,EACR,YAAY,EACZ,MAAM,EACN,YAAiB,EACjB,QAAe,EACf,gBAAgB,EACnB,EAAE,mBAAmB,2CAqNrB;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,kBAAkB,CAM9C"}