", bc, esc(body)))
}
if href != "" {
card.WriteString("")
}
card.WriteString("")
return card.String()
}
func renderArticle(it map[string]any) string {
title := text(it["title"])
body := text(it["body"])
meta := text(it["meta"])
tag := text(it["tag"])
var s strings.Builder
s.WriteString(``)
if meta != "" {
s.WriteString(fmt.Sprintf(`
%s
`, esc(meta)))
}
s.WriteString(fmt.Sprintf(`
%s
`, esc(title)))
if tag != "" {
s.WriteString(fmt.Sprintf(`
%s
`, esc(tag)))
}
if body != "" {
// Minimal: escape as paragraphs (full markdown deferred).
s.WriteString(fmt.Sprintf(`
%s
`, esc(body)))
}
s.WriteString("")
return s.String()
}
func renderPagination(page map[string]any, total int64, itemCount int) string {
p, ok := page["paginate"].(map[string]any)
if !ok {
return ""
}
offset := int64(0)
limit := int64(10)
if v, ok := p["offset"].(float64); ok {
offset = int64(v)
}
if v, ok := p["limit"].(float64); ok {
limit = int64(v)
}
if limit <= 0 {
return ""
}
path := "/"
if s, ok := p["path"].(string); ok {
path = s
}
var s strings.Builder
s.WriteString(`")
return s.String()
}
func pushIntro(buf *strings.Builder, intro string) {
if intro != "" {
buf.WriteString(fmt.Sprintf(`
%s
`, intro))
}
}
func renderFragment(page map[string]any, dbURL, slot string) string {
slot = table.NormalizeSlot(slot)
switch slot {
case "nav":
links := resolveLinks(page["nav"], dbURL, page)
return fmt.Sprintf(
`%s`,
renderULWithMQ(links, "nav", nil),
)
case "sidebar":
links := resolveLinks(page["sidebar"], dbURL, page)
return fmt.Sprintf(
``,
renderULWithMQ(links, "side-nav", nil),
)
case "footer":
links := resolveLinks(page["footer"], dbURL, page)
return fmt.Sprintf(
``,
renderULWithMQ(links, "foot-nav", nil),
)
default:
intro, items, _ := resolveMain(page, dbURL)
var body strings.Builder
pushIntro(&body, intro)
if len(items) > 0 {
isDetail, _ := page["detail"].(bool)
if isDetail {
body.WriteString(renderArticle(items[0]))
} else {
body.WriteString(``)
for _, it := range items {
body.WriteString(renderCard(page, it))
}
body.WriteString(``)
}
}
return fmt.Sprintf(`%s`, body.String())
}
}
// RenderPage builds full-page HTML (or a part fragment when partID is set).
func RenderPage(page map[string]any, dbURL string, partID string) string {
if page == nil {
page = map[string]any{}
}
if partID != "" {
parts, _ := page["parts"].(map[string]any)
if parts != nil {
if cfg, ok := parts[partID].(map[string]any); ok {
merged := map[string]any{}
for k, v := range page {
merged[k] = v
}
for k, v := range cfg {
merged[k] = v
}
slot, _ := cfg["slot"].(string)
if slot == "" {
slot, _ = cfg["fragment"].(string)
}
if slot == "" {
slot = "main"
}
return renderFragment(merged, dbURL, slot)
}
}
return renderFragment(page, dbURL, partID)
}
title := "Marqdo Web"
if t, ok := page["title"].(string); ok && t != "" {
title = t
}
shell := resolveShellCSS(page)
layout := resolveLayout(page)
parts, _ := page["parts"].(map[string]any)
if parts == nil {
parts = map[string]any{}
}
nav := resolveLinks(page["nav"], dbURL, page)
side := resolveLinks(page["sidebar"], dbURL, page)
foot := resolveLinks(page["footer"], dbURL, page)
intro, items, total := resolveMain(page, dbURL)
navCSS, mqPairs := navMediaClassMapMany(nav, side, foot)
extra, _ := page["styles_css"].(string)
if navCSS != "" {
if extra != "" {
extra += "\n"
}
extra += navCSS
}
_, hasSideKey := page["sidebar"]
hasSide := hasSideKey || len(side) > 0
bare := layout == "bare"
var bodyClass string
switch layout {
case "bare":
bodyClass = "layout-bare"
case "stacked":
bodyClass = "layout-stacked"
case "rail":
if hasSide {
bodyClass = "has-rail has-sidebar"
} else {
bodyClass = "has-rail no-sidebar"
}
case "sidebar":
if hasSide {
bodyClass = "has-sidebar"
} else {
bodyClass = "no-sidebar"
}
case "":
if hasSide {
bodyClass = "has-sidebar"
} else {
bodyClass = "no-sidebar"
}
default:
bodyClass = layout
}
var mainHTML strings.Builder
if images, ok := page["images_html"].(string); ok && images != "" {
mainHTML.WriteString(images)
}
pushIntro(&mainHTML, intro)
if len(items) > 0 {
isDetail, _ := page["detail"].(bool)
if isDetail {
mainHTML.WriteString(renderArticle(items[0]))
} else {
mainHTML.WriteString(``)
for _, it := range items {
mainHTML.WriteString(renderCard(page, it))
}
mainHTML.WriteString(``)
}
if total != nil {
mainHTML.WriteString(renderPagination(page, *total, len(items)))
}
}
styleBlock := ""
if shell != "" || extra != "" {
styleBlock = fmt.Sprintf("", shell, extra)
}
showChrome := !bare
sideHTML := ""
if showChrome && hasSide {
sideHTML = fmt.Sprintf(
``,
slotClass(page, "sidebar", "side"),
slotAttrs("sidebar", parts, page),
renderULWithMQ(side, "side-nav", mqPairs),
)
}
headerHTML := ""
if showChrome {
headerHTML = fmt.Sprintf(
`%s`,
slotClass(page, "nav", "topnav"),
slotAttrs("nav", parts, page),
renderULWithMQ(nav, "nav", mqPairs),
)
}
footerHTML := ""
if showChrome {
footerHTML = fmt.Sprintf(
``,
slotClass(page, "footer", "foot"),
slotAttrs("footer", parts, page),
renderULWithMQ(foot, "foot-nav", mqPairs),
)
}
return fmt.Sprintf(`
%s
%s
%s
%s
%s
%s
`,
headHTML(page, title),
styleBlock,
bodyClass,
headerHTML,
sideHTML,
slotClass(page, "main", "main"),
slotAttrs("main", parts, page),
mainHTML.String(),
footerHTML,
)
}