157 lines
3.8 KiB
Go
157 lines
3.8 KiB
Go
package html
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
)
|
|
|
|
// Compile-time interface check.
|
|
var _ Node = (*Layout)(nil)
|
|
|
|
// ErrInvalidLayoutVariant reports that a layout variant string contains at
|
|
// least one unrecognised slot character.
|
|
var ErrInvalidLayoutVariant = errors.New("html: invalid layout variant")
|
|
|
|
// slotMeta holds the semantic HTML mapping for each HLCRF slot.
|
|
type slotMeta struct {
|
|
tag string
|
|
role string
|
|
}
|
|
|
|
// slotRegistry maps slot letters to their semantic HTML elements and ARIA roles.
|
|
var slotRegistry = map[byte]slotMeta{
|
|
'H': {tag: "header", role: "banner"},
|
|
'L': {tag: "aside", role: "complementary"},
|
|
'C': {tag: "main", role: "main"},
|
|
'R': {tag: "aside", role: "complementary"},
|
|
'F': {tag: "footer", role: "contentinfo"},
|
|
}
|
|
|
|
// Layout is an HLCRF compositor. Arranges nodes into semantic HTML regions
|
|
// with deterministic path-based IDs.
|
|
type Layout struct {
|
|
variant string // "HLCRF", "HCF", "C", etc.
|
|
path string // "" for root, "L-0-" for nested
|
|
slots map[byte][]Node // H, L, C, R, F → children
|
|
variantErr error
|
|
}
|
|
|
|
// NewLayout creates a new Layout with the given variant string.
|
|
// The variant determines which slots are rendered (e.g., "HLCRF", "HCF", "C").
|
|
func NewLayout(variant string) *Layout {
|
|
l := &Layout{
|
|
variant: variant,
|
|
slots: make(map[byte][]Node),
|
|
}
|
|
l.variantErr = ValidateLayoutVariant(variant)
|
|
return l
|
|
}
|
|
|
|
// ValidateLayoutVariant reports whether a layout variant string contains only
|
|
// recognised slot characters.
|
|
func ValidateLayoutVariant(variant string) error {
|
|
var invalid bool
|
|
for i := range len(variant) {
|
|
if _, ok := slotRegistry[variant[i]]; ok {
|
|
continue
|
|
}
|
|
invalid = true
|
|
break
|
|
}
|
|
if !invalid {
|
|
return nil
|
|
}
|
|
return &layoutVariantError{variant: variant}
|
|
}
|
|
|
|
// H appends nodes to the Header slot.
|
|
func (l *Layout) H(nodes ...Node) *Layout {
|
|
l.slots['H'] = append(l.slots['H'], nodes...)
|
|
return l
|
|
}
|
|
|
|
// L appends nodes to the Left aside slot.
|
|
func (l *Layout) L(nodes ...Node) *Layout {
|
|
l.slots['L'] = append(l.slots['L'], nodes...)
|
|
return l
|
|
}
|
|
|
|
// C appends nodes to the Content (main) slot.
|
|
func (l *Layout) C(nodes ...Node) *Layout {
|
|
l.slots['C'] = append(l.slots['C'], nodes...)
|
|
return l
|
|
}
|
|
|
|
// R appends nodes to the Right aside slot.
|
|
func (l *Layout) R(nodes ...Node) *Layout {
|
|
l.slots['R'] = append(l.slots['R'], nodes...)
|
|
return l
|
|
}
|
|
|
|
// F appends nodes to the Footer slot.
|
|
func (l *Layout) F(nodes ...Node) *Layout {
|
|
l.slots['F'] = append(l.slots['F'], nodes...)
|
|
return l
|
|
}
|
|
|
|
// blockID returns the deterministic data-block attribute value for a slot.
|
|
func (l *Layout) blockID(slot byte) string {
|
|
return l.path + string(slot) + "-0"
|
|
}
|
|
|
|
// VariantError reports whether the layout variant string contained any invalid
|
|
// slot characters when the layout was constructed.
|
|
func (l *Layout) VariantError() error {
|
|
if l == nil {
|
|
return nil
|
|
}
|
|
return l.variantErr
|
|
}
|
|
|
|
// Render produces the semantic HTML for this layout.
|
|
// Only slots present in the variant string are rendered.
|
|
func (l *Layout) Render(ctx *Context) string {
|
|
var b strings.Builder
|
|
|
|
for i := range len(l.variant) {
|
|
slot := l.variant[i]
|
|
children := l.slots[slot]
|
|
|
|
meta, ok := slotRegistry[slot]
|
|
if !ok {
|
|
continue
|
|
}
|
|
|
|
bid := l.blockID(slot)
|
|
|
|
b.WriteByte('<')
|
|
b.WriteString(escapeHTML(meta.tag))
|
|
b.WriteString(` role="`)
|
|
b.WriteString(escapeAttr(meta.role))
|
|
b.WriteString(`" data-block="`)
|
|
b.WriteString(escapeAttr(bid))
|
|
b.WriteString(`">`)
|
|
|
|
for _, child := range children {
|
|
b.WriteString(renderNodeWithPath(child, ctx, bid+"-"))
|
|
}
|
|
|
|
b.WriteString("</")
|
|
b.WriteString(meta.tag)
|
|
b.WriteByte('>')
|
|
}
|
|
|
|
return b.String()
|
|
}
|
|
|
|
type layoutVariantError struct {
|
|
variant string
|
|
}
|
|
|
|
func (e *layoutVariantError) Error() string {
|
|
return "html: invalid layout variant " + e.variant
|
|
}
|
|
|
|
func (e *layoutVariantError) Unwrap() error {
|
|
return ErrInvalidLayoutVariant
|
|
}
|