frontend

type BlockRenderer ¶ added in v1.14.0

type BlockRenderer interface {
	// Render renders the block content and returns the HTML
	Render(ctx context.Context, block cmsstore.BlockInterface) (string, error)
}

BlockRenderer interface defines how different block types are rendered.

Custom block renderers must implement this interface to integrate with the block rendering system. Each renderer is responsible for converting a block's content into HTML output.

Example implementation:

type GalleryRenderer struct {
    store FrontendStore
}

func (r *GalleryRenderer) Render(ctx context.Context, block cmsstore.BlockInterface) (string, error) {
    // Parse block content and metadata
    images := parseGalleryImages(block.Content())
    layout := block.Meta("layout")

    // Generate HTML
    return renderGalleryHTML(images, layout), nil
}

To register a custom renderer:

frontend := cmsstore.NewFrontend(...)
frontend.BlockRegistry().Register("gallery", &GalleryRenderer{store: frontend})

See frontend/blocks/README.md for detailed examples and best practices.

type BlockRendererRegistry ¶ added in v1.14.0

type BlockRendererRegistry struct {
	// contains filtered or unexported fields
}

BlockRendererRegistry manages all registered block renderers.

The registry is thread-safe and can be accessed concurrently. It maps block types (strings) to their corresponding BlockRenderer implementations.

Built-in block types:

• cmsstore.BLOCK_TYPE_HTML: Renders raw HTML content
• cmsstore.BLOCK_TYPE_MENU: Renders navigation menus

Custom block types can be registered after frontend initialization:

frontend.BlockRegistry().Register("custom_type", customRenderer)

func NewBlockRendererRegistry() *BlockRendererRegistry

func (r *BlockRendererRegistry) GetRenderer(blockType string) BlockRenderer

func (r *BlockRendererRegistry) Register(blockType string, renderer BlockRenderer)

frontend.BlockRegistry().Register("video", &VideoRenderer{})
frontend.BlockRegistry().Register("carousel", &CarouselRenderer{store: frontend})

func (r *BlockRendererRegistry) RenderBlock(ctx context.Context, block cmsstore.BlockInterface) (string, error)

type Config ¶

type Config struct {
	// BlockEditorRenderer converts block editor JSON content to HTML.
	// Required if using block editor pages.
	BlockEditorRenderer func(blocks []ui.BlockInterface) string
	// Logger is used for structured logging. If nil, logging is disabled.
	Logger *slog.Logger

	// Shortcodes are custom shortcode handlers for content processing.
	Shortcodes []cmsstore.ShortcodeInterface

	// Store provides access to CMS data (pages, blocks, templates, etc.).
	// Required for frontend operation.
	Store cmsstore.StoreInterface

	// CacheEnabled enables in-memory caching of rendered content.
	CacheEnabled bool

	// CacheExpireSeconds sets the TTL for cached items.
	// Defaults to 600 seconds (10 minutes) if not set or <= 0.
	CacheExpireSeconds int

	// PageNotFoundHandler is called when a page is not found.
	// If it returns handled=true, the frontend will use the result and skip the default 404 response.
	PageNotFoundHandler func(w http.ResponseWriter, r *http.Request, alias string) (handled bool, result string)
}

Config holds the configuration options for creating a new Frontend instance. All fields are optional and have sensible defaults if not provided.

type FrontendInterface ¶

type FrontendInterface interface {
	// Handler renders the frontend
	Handler(w http.ResponseWriter, r *http.Request)

	// StringHandler return the frontend as a HTML string
	StringHandler(w http.ResponseWriter, r *http.Request) string

	// TemplateRenderHtmlByID builds the HTML of a template based on its ID
	TemplateRenderHtmlByID(r *http.Request, templateID string, options TemplateRenderHtmlByIDOptions) (string, error)
}

func New(config Config) FrontendInterface

frontend := New(Config{
    Store:               store,
    Logger:              logger,
    BlockEditorRenderer: myRenderer,
    CacheEnabled:        true,
    CacheExpireSeconds:  300,
})

type LanguageKey ¶

type LanguageKey struct{}

type NoOpRenderer ¶ added in v1.14.0

type NoOpRenderer struct{}

NoOpRenderer is a fallback renderer that returns empty content

func (r *NoOpRenderer) Render(ctx context.Context, block cmsstore.BlockInterface) (string, error)

type TemplateRenderHtmlByIDOptions ¶

type TemplateRenderHtmlByIDOptions struct {
	PageContent         string
	PageCanonicalURL    string
	PageMetaDescription string
	PageMetaKeywords    string
	PageMetaRobots      string
	PageTitle           string
	Language            string
}