@jhits/plugin-blog 0.0.7 → 0.0.9

package/dist/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?.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/dist/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/dist/lib/rich-text/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/rich-text/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/dist/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/dist/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/dist/lib/utils/blockHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockHelpers.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/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/dist/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?.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/dist/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/dist/lib/utils/configValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configValidation.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/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/dist/lib/utils/configValidation.js

@@ -0,0 +1,111 @@
+/**
+ * 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(() => {
+        // 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 (window.__JHITS_PLUGIN_PROPS__?.['plugin-blog']?.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 = () => {
+            const windowGlobal = window.__JHITS_PLUGIN_PROPS__?.['plugin-blog']?.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/dist/lib/utils/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Utility exports
+ */
+export * from './slugify';
+export * from './blockHelpers';
+export * from './configValidation';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC"}

package/dist/lib/utils/index.js

@@ -0,0 +1,6 @@
+/**
+ * Utility exports
+ */
+export * from './slugify';
+export * from './blockHelpers';
+export * from './configValidation';

package/dist/lib/utils/slugify.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Slug Utilities
+ * Functions for generating and validating URL slugs
+ */
+/**
+ * Convert a string to a URL-friendly slug
+ */
+export declare function slugify(text: string): string;
+/**
+ * Generate a slug from a title
+ * Automatically handles edge cases and ensures uniqueness
+ */
+export declare function generateSlugFromTitle(title: string, existingSlugs?: string[]): string;
+/**
+ * Validate a slug format
+ */
+export declare function isValidSlug(slug: string): boolean;
+/**
+ * Check if a slug collides with existing slugs
+ */
+export declare function checkSlugCollision(slug: string, existingSlugs: string[], excludeId?: string): {
+    isCollision: boolean;
+    conflictingId?: string;
+};
+//# sourceMappingURL=slugify.d.ts.map

package/dist/lib/utils/slugify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slugify.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/slugify.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAU5C;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,GAAE,MAAM,EAAO,GAAG,MAAM,CAkBzF;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAIjD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG;IAC3F,WAAW,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B,CAkBA"}

package/dist/lib/utils/slugify.js

@@ -0,0 +1,65 @@
+/**
+ * Slug Utilities
+ * Functions for generating and validating URL slugs
+ */
+/**
+ * Convert a string to a URL-friendly slug
+ */
+export function slugify(text) {
+    return text
+        .toString()
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, '-') // Replace spaces with hyphens
+        .replace(/[^\w\-]+/g, '') // Remove all non-word chars
+        .replace(/\-\-+/g, '-') // Replace multiple hyphens with single hyphen
+        .replace(/^-+/, '') // Trim hyphens from start
+        .replace(/-+$/, ''); // Trim hyphens from end
+}
+/**
+ * Generate a slug from a title
+ * Automatically handles edge cases and ensures uniqueness
+ */
+export function generateSlugFromTitle(title, existingSlugs = []) {
+    let baseSlug = slugify(title);
+    // If slug is empty after processing, use a fallback
+    if (!baseSlug) {
+        baseSlug = 'untitled-post';
+    }
+    // Check for collisions and append number if needed
+    let finalSlug = baseSlug;
+    let counter = 1;
+    while (existingSlugs.includes(finalSlug)) {
+        finalSlug = `${baseSlug}-${counter}`;
+        counter++;
+    }
+    return finalSlug;
+}
+/**
+ * Validate a slug format
+ */
+export function isValidSlug(slug) {
+    // Slug should be lowercase, alphanumeric with hyphens
+    const slugRegex = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+    return slugRegex.test(slug) && slug.length > 0 && slug.length <= 200;
+}
+/**
+ * Check if a slug collides with existing slugs
+ */
+export function checkSlugCollision(slug, existingSlugs, excludeId) {
+    // Normalize the slug for comparison
+    const normalizedSlug = slug.toLowerCase().trim();
+    // Check against existing slugs (excluding current post if editing)
+    for (const existing of existingSlugs) {
+        if (existing.toLowerCase().trim() === normalizedSlug) {
+            // If we have an excludeId, we need to check if this is the same post
+            // This would require additional context (like a post ID map)
+            // For now, we'll return collision if it matches
+            return {
+                isCollision: true,
+                conflictingId: existing,
+            };
+        }
+    }
+    return { isCollision: false };
+}

package/dist/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/dist/registry/BlockRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockRegistry.d.ts","sourceRoot":"","sources":["../../src/registry/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"}