136 lines
3.4 KiB
Go
136 lines
3.4 KiB
Go
package html
|
|
|
|
import (
|
|
"maps"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
// responsive.go: Responsive wraps multiple Layout variants for breakpoint-aware rendering.
|
|
// Example: NewResponsive().Variant("desktop", NewLayout("C").C(Raw("main"))).
|
|
// Each variant is rendered inside a container with data-variant for CSS targeting.
|
|
type Responsive struct {
|
|
variants []responsiveVariant
|
|
attrs map[string]string
|
|
}
|
|
|
|
type responsiveVariant struct {
|
|
name string
|
|
layout *Layout
|
|
}
|
|
|
|
// responsive.go: NewResponsive creates a new multi-variant responsive compositor.
|
|
// Example: r := NewResponsive().
|
|
func NewResponsive() *Responsive {
|
|
return &Responsive{
|
|
attrs: make(map[string]string),
|
|
}
|
|
}
|
|
|
|
func (r *Responsive) setAttr(key, value string) {
|
|
if r == nil {
|
|
return
|
|
}
|
|
if r.attrs == nil {
|
|
r.attrs = make(map[string]string)
|
|
}
|
|
r.attrs[key] = value
|
|
}
|
|
|
|
// escapeCSSString escapes a string for safe use inside a double-quoted CSS
|
|
// attribute selector.
|
|
func escapeCSSString(s string) string {
|
|
var b strings.Builder
|
|
for _, r := range s {
|
|
switch r {
|
|
case '\\', '"':
|
|
b.WriteByte('\\')
|
|
b.WriteRune(r)
|
|
case '\n':
|
|
b.WriteString(`\a `)
|
|
case '\r':
|
|
b.WriteString(`\d `)
|
|
case '\f':
|
|
b.WriteString(`\c `)
|
|
default:
|
|
if r < 0x20 || r == 0x7f {
|
|
b.WriteByte('\\')
|
|
b.WriteString(strings.ToLower(strconv.FormatInt(int64(r), 16)))
|
|
b.WriteByte(' ')
|
|
continue
|
|
}
|
|
b.WriteRune(r)
|
|
}
|
|
}
|
|
return b.String()
|
|
}
|
|
|
|
// responsive.go: VariantSelector returns a CSS attribute selector for a named responsive variant.
|
|
// Example: VariantSelector("desktop") returns [data-variant="desktop"].
|
|
func VariantSelector(name string) string {
|
|
return `[data-variant="` + escapeCSSString(name) + `"]`
|
|
}
|
|
|
|
// responsive.go: ScopeVariant prefixes a selector so it only matches elements inside the
|
|
// named responsive variant.
|
|
// Example: ScopeVariant("desktop", ".nav").
|
|
func ScopeVariant(name, selector string) string {
|
|
scope := VariantSelector(name)
|
|
if selector == "" {
|
|
return scope
|
|
}
|
|
|
|
parts := strings.Split(selector, ",")
|
|
for i := range parts {
|
|
parts[i] = strings.TrimSpace(parts[i])
|
|
if parts[i] == "" {
|
|
continue
|
|
}
|
|
parts[i] = scope + " " + parts[i]
|
|
}
|
|
return strings.Join(parts, ", ")
|
|
}
|
|
|
|
// responsive.go: Variant adds a named layout variant (e.g., "desktop", "tablet", "mobile").
|
|
// Example: r.Variant("mobile", NewLayout("C").C(Raw("body"))).
|
|
// Variants render in insertion order.
|
|
func (r *Responsive) Variant(name string, layout *Layout) *Responsive {
|
|
r.variants = append(r.variants, responsiveVariant{name: name, layout: layout})
|
|
return r
|
|
}
|
|
|
|
// responsive.go: Render produces HTML with each variant in a data-variant container.
|
|
// Example: NewResponsive().Variant("desktop", NewLayout("C")).Render(NewContext()).
|
|
func (r *Responsive) Render(ctx *Context) string {
|
|
return r.renderWithPath(ctx, "")
|
|
}
|
|
|
|
func (r *Responsive) renderWithPath(ctx *Context, path string) string {
|
|
if r == nil {
|
|
return ""
|
|
}
|
|
ctx = normaliseContext(ctx)
|
|
|
|
var b strings.Builder
|
|
for _, v := range r.variants {
|
|
b.WriteString(`<div`)
|
|
if len(r.attrs) > 0 {
|
|
keys := slices.Collect(maps.Keys(r.attrs))
|
|
slices.Sort(keys)
|
|
for _, key := range keys {
|
|
b.WriteByte(' ')
|
|
b.WriteString(escapeHTML(key))
|
|
b.WriteString(`="`)
|
|
b.WriteString(escapeAttr(r.attrs[key]))
|
|
b.WriteByte('"')
|
|
}
|
|
}
|
|
b.WriteString(` data-variant="`)
|
|
b.WriteString(escapeAttr(v.name))
|
|
b.WriteString(`">`)
|
|
b.WriteString(renderNodeWithPath(v.layout, ctx, path))
|
|
b.WriteString(`</div>`)
|
|
}
|
|
return b.String()
|
|
}
|